MIVC503 Conclusion

Modern society has become inextricably linked with digital technology, the virtualisation of processes and ‘things’ beginning to overtake the tangible. Inspired by N. Katherine Hayles "How We Became Posthuman", my project explores the inevitable (or perhaps existing) coalesce of human and digital ‘information’. By recontextualising the human genome code within the environment of computer programming, I believe both the concept app and tutorial clearly question what this interlock will mean with regards to evolution; Being able to ‘mutate’ or rewrite one’s own genetic make-up through a widely accessible programme, would allow users to completely change their appearance at the push of a button. This is conveyed in the tutorial where I change into a young boy and carried further in the app displaying a ‘clone’, ‘delete’ and ‘send’ button, just who is God in this future? The human genome code displayed at the Wellcome Collection has been a significant influence to the project, already signifying the ‘decoding’ of human beings, I believed it to be the most successful way to illustrate human beings as a set of instructions which only await the fate of being edited within a digital environment. There has become an app for just about everything replacing many physical processes, almost epitomising the extent to which technology has spread, therefore I chose the form as the perfect platform for my genomic editing programme to sit, explicating the scope of what is plausible in the future. Youtube tutorials on how to write computer programmes are posted in abundance, perceived as the norm and common knowledge among the current generation; by adopting this form the genome editing programme or ‘Genedit’ is placed in relation to the existing tutorials, and through this contamination is normalised, creating the impact and enforcing the inevitability of the conflate of informations. The concept is portrayed clearly and appropriately through the forms it adopts, however I believe the app could have been pushed further and would have carried more of an impact if the app or programme was actually created, able to be displayed on a physical iphone, which is where my technical abilities of programming have let me down (perhaps I would be one of those to become extinct in the the future unable to mutate!).

Design

Screen 1 imitates a QR reader using the guide boxes to to achieve optimum focus and read the skin/body as it were a code. This is the first signification of the body as information.

Screen 2 adopts the fragments of skin lifted from photographs that was used on the title screen and app icon. This not only creates a 'theme' ensuring a parity between all pages, but also depicts the 'breakdown' or decoding of the body beginning; much like the icon the colours are flattened to create a 2 dimensional image. In this screen the user selects the gene string to be edited using the touch screen to position the polygon over the appropriate 'label' or 'tag'. I used a polygon as a reflection of how dna is often displayed :

enforcing the idea of body as code, and the tags attempt to convey the image of instructions, an almost how to build the body as if something from ikea. This asks multiple questions in itself, simplifying such a complex and (once) mysterious organism of life and the body into a series of tags and geometrical forms, are we really so complex or superior?

Screen 3 adopts the design of a programme editing/writing app such as wordpress, being very basic in design using the standard iphone/ipad presets for colour, background and keypad, and an almost primal, in terms of the computer, font. A few of the keys and buttons have been modified on the keypad however, as the genome code is only written using four different letters of 'T' 'A' 'C' and 'G'. The 'clone' button attempts to highlight its similarities with copying and pasting, it normalises the process of cloning and portrays it as completely accessible, asking in who's hands will creation lie in the future? The 'delete' button is described as enabling the user to destroy the gene, asking who in the future will have the ability or right to take someones life? The screen as a whole, allowing users to edit their genome and create mutations relates to evolution. Much like xmen who from their gene mutations are the evolved human being, this entwining of digital and human information may be our evolved form, growing extra limbs if needed even stronger organs, removing illnesses such as cancer. When thinking about computer programming it is fair to say that while the younger generation have embraced it, the older generation feels alienated and is completely 'unconnected' as it were. What happens to the older generations or those who do not grasp the technology? While others mutate and evolve they do not, and possibly through natural selection are extinct.

Screen 4 assumes a similar format and design to screen 3 with the basic font and standard buttons, whilst tying in with the theme and using the fragmented skin as its background. The buttons allow users to send existing or mutated genes to their phone's contacts. This portrays both positive and negative outcomes: one possibility is 'normal' or 'debugged' genes can be sent to those with mutated genes (which have lead to illness), in theory curing illnesses such as cancer, the human genome project is widely used by cancer research and so this idea is quite relevant. The alternate outcome would be that mutated genes leading to illness can be sent to healthy people, and thus causing illness, comparable to computer viruses being sent and spread via the internet or downloaded files. The later could result in the 'crash' of complete 'networks' of friends or families and even the human race.

I used adobe device central to emulate my app but just used it purely to take snapshots above. Device central is a popular way for apps to be shared with possible clients and businesses and so I think contextualising my app within this environment is appropriate.

Using adobe device central to create my concept app.

For the design of the app icon I attempted to create a juxtaposition with the icon of processing, rendering it almost oxymoronic, in that instead of conveying a physical quality for the code, I inverted this to remove the tangible qualities and convey the body as information. I adopted the formalistic qualities of Processing, using sharp angles to fragment the face which then has sections and layers removed which also removes the depth. Reducing the tone and using flat colour also contributes to this. To clearly signify the link with code, I overlayed sections of the human genome code in a basic sans serif font, similar to that used in code writing programmes.

Genedit Tutorial

Here's the final tutorial. I thought the appropriate host for the video would be youtube as most tutorials use this, although below is a the video on vimeo for viewing purposes as I think it has a better format.

A screen shot taken from the programme I made using processing which, by activating the webcam, translate the image into 1 and 0's - binary. However, Im at a loss of to how to upload/ run the programme anywhere other than my own laptop, so instead the script is below:

/**
 * ASCII Video
 * by Ben Fry. 
 * 
 * Text characters have been used to represent images since the earliest computers.
 * This sketch is a simple homage that re-interprets live video as ASCII text.
 * See the keyPressed function for more options, like changing the font size.
 */

import processing.video.*;

Capture video;
boolean cheatScreen;

// All ASCII characters, sorted according to their visual density
String letterOrder =
  " .`-_':,;^=+/\"|)\\<>)iv%xclrs{*}I?!][1taeo7zjLu" +
  "1000100010111100101001010101010100101010010";
char[] letters;

float[] bright;
char[] chars;

PFont font;
float fontSize = 1.5;


public void setup() {
  size(640, 480, P2D);
  // Or run full screen, more fun! Use with Sketch -> Present
  //size(screen.width, screen.height, OPENGL);

  // Uses the default video input, see the reference if this causes an error
  video = new Capture(this, 80, 60, 15);
  int count = video.width * video.height;

  font = loadFont("UniversLTStd-Light-48.vlw");

  // for the 256 levels of brightness, distribute the letters across
  // the an array of 256 elements to use for the lookup
  letters = new char[256];
  for (int i = 0; i < 256; i++) {
    int index = int(map(i, 0, 256, 0, letterOrder.length()));
    letters[i] = letterOrder.charAt(index);
  }

  // current characters for each position in the video
  chars = new char[count];

  // current brightness for each point
  bright = new float[count];
  for (int i = 0; i < count; i++) {
    // set each brightness at the midpoint to start
    bright[i] = 128;
  }
}


public void captureEvent(Capture c) {
  c.read();
}


void draw() {
  background(0);

  pushMatrix();

  float hgap = width / float(video.width);
  float vgap = height / float(video.height);

  scale(max(hgap, vgap) * fontSize);
  textFont(font, fontSize);

  int index = 0;
  for (int y = 1; y < video.height; y++) {

    // Move down for next line
    translate(0,  1.0 / fontSize);

    pushMatrix();
    for (int x = 0; x < video.width; x++) {
      int pixelColor = video.pixels[index];
      // Faster method of calculating r, g, b than red(), green(), blue() 
      int r = (pixelColor >> 16) & 0xff;
      int g = (pixelColor >> 8) & 0xff;
      int b = pixelColor & 0xff;

      // Another option would be to properly calculate brightness as luminance:
      // luminance = 0.3*red + 0.59*green + 0.11*blue
      // Or you could instead red + green + blue, and make the the values[] array
      // 256*3 elements long instead of just 256.
      int pixelBright = max(r, g, b);

      // The 0.1 value is used to damp the changes so that letters flicker less
      float diff = pixelBright - bright[index];
      bright[index] += diff * 0.1;

      fill(pixelColor);
      int num = int(bright[index]);
      text(letters[num], 0, 0);
      
      // Move to the next pixel
      index++;

      // Move over for next character
      translate(1.0 / fontSize, 0);
    }
    popMatrix();
  }
  popMatrix();

  if (cheatScreen) {
    //image(video, 0, height - video.height);
    // set() is faster than image() when drawing untransformed images
    set(0, height - video.height, video);
  }
}


/**
 * Handle key presses:
 * 'c' toggles the cheat screen that shows the original image in the corner
 * 'g' grabs an image and saves the frame to a tiff image
 * 'f' and 'F' increase and decrease the font size
 */
public void keyPressed() {
  switch (key) {
    case 'g': saveFrame(); break;
    case 'c': cheatScreen = !cheatScreen; break;
    case 'f': fontSize *= 1.1; break;
    case 'F': fontSize *= 0.9; break;
  }
}

Tying the tutorial in with the concept app, I photoshopped the itunes window to display the genedit app which will feature in the tutorial. By analysing a lot of youtube tutorials I found reoccurring characteristics which will be deployed within my own. Most are done through a simple screen recording and take on a very informal, relaxed tone, using colloquial language and in fact most of the people making the tutorials are fairly young. Despite being a tutorial, intending to explain 'how to', there isn't a great deal of specific or detailed information given, terms are casually mentioned with no reference to what they actually mean, relating to this almost new language which one must adopt in order to continue, perhaps an indication of evolution itself...but I digress. The tutorials generally end with a plea to subscribe to the makers channel or watch their other videos, and tend to remain as they were recorded, unedited and straight forward, lasting around 2-3 minutes.

A few sections from the Kevin Kelly's 'What Technology Wants'. The inevitability of technology's evolution is made clear for the reader as Kelly explores the evolution of humanity, making reference to the nature of gene mutations as not as random as once believed, but display and function in patterns as that of computer data. My project ties in with this notion fairly well, agreeing that in terms of natural selection it seems that technology is a necessity to survive in current times, and as its 'evolution' or advancements begin to overtake that of humanity, it is only inevitable that technology and humanity blend with one another, evolving.

I decided to add another feature to the app which allows users to send the mutated gene or a 'pre-made' gene mutation to their contacts. This notion is perhaps the most sinister of all the features, operating very much like a computer virus (and therefore portraying the intwining of technologies) to alter, copy or destroy another body's 'data'.

Looking at the overlap of technologies and app in a positive light, the possibilities are that with many more people developing and editing genes, cures to illnesses such as cancer may be found, or symptoms identified earlier. A child with a mutated gene resulting in Wilms tumour can be sent a 'normal' sequence of that genome and be cured, a generation of DIY or virtual doctors may emerge.