This week I chose a project by a company, “Spacetime Coordinates”. It is an art project that brings a personalized map of the positions of the planets at the calculated day of one’s birth. The company extracts NASA data and algorithms to compute the random positions of the planets to create a customized print. The company has created minimal style posters in the colors of dark blue, black, and white. I think what is really great about this project is the fact that no two date entries provide the same map. It is amazing how you can plug in a random date and see the snapshot of the solar system of that day, visualized into a minimal map. The style of the posters are very simple, with thin colored curves resembling orbits and small circles representing planets. The company has also created 3D printed metal casted sculptures which present personal planetary information. All of their works seem interested in displaying unique and personalized planetary positions, and are all made in a minimal style.

images of the poster



rgroves – Looking Outwards-06

Random Selection in Random Image by Jan Robert Leegt in not a complicated project. It’s a website that selects a random image from Flickr and makes a selects an area of the image of random size and location. I doubt this project required a great deal of thought or effort, but nevertheless it messes with your mind in a really interesting way. Even though I know the selections were made randomly, my mind has to find some significance to the selection so it fills in information that’s not there. This can create an eerie effect – for example in this picture my mind is telling me that someone is looking out at me from those two dark windows.

It is also interesting how often the random selection looks less random than if someone was trying to make it look random. For example, in this picture the program happened to select the main subject of the picture.



(Bogdan Soban, Fire valley, http://ieeexplore.ieee.org/document/1683685/?reason=concurrency)

Soban is a generative artist that experiments with different computer programs to make algorithmic art. His initial inspirations came from his admiration of machines. He deeply respected the machines’ capability to process things better than humans and therefore wanted to gift them creativity. Utilizing the advantage of algorithmic programming, Soban started to create these randomized art.

To make this “Fire Valley” piece, Soban used solar systems to disturb the generative algorithms in his program. He wanted to give more randomization to the piece in order to truly transform the solar energy into his artwork. I admire Soban’s choice of algorithm. It is unusual to actually bring in the source of what he wants to depict to govern the artwork. In this case, solar energy successfully gave the product life. His passion is very much respected.



function setup() {
  createCanvas(400, 250);

function draw() {
  background(255, 225, 225);

  //strawberry jam jar
  fill(255, 26, 26);
  ellipse(70, 170, 100, 30);
  line(20, 40, 20, 170);
  line(120, 40, 120, 170);
  ellipse(70, 40, 100, 30);
  fill(255, 26, 26);
  ellipse(70, 40, 30, 10);

  //raspberry jam jar
  fill(102, 0, 34);
  ellipse(200, 170, 100, 30);
  line(150, 40, 150, 170);
  line(250, 40, 250, 170);
  ellipse(200, 40, 100, 30);
  fill(102, 0, 34);
  ellipse(200, 40, 30, 10);

  //apricot jam jar
  fill(240, 90, 26);
  ellipse(330, 170, 100, 30);
  line(280, 40, 280, 170);
  line(380, 40, 380, 170);
  ellipse(330, 40, 100, 30);
  fill(240, 90, 26);
  ellipse(330, 40, 30, 10);

  var h = hour();
  var m = minute();
  var s = second();

  //height of jam based on time
  var maph = map(h, 0, 23, 0, height / 2.25);
  var mapm = map(m, 0, 59, 0, height / 2.25);
  var maps = map(s, 0, 59, 0, height / 2.25);


  //strawberry jam
  fill(255, 26, 26);
  rect(20, 170, 100, - maps)

  //raspberry jam
  fill(102, 0, 34);
  rect(150, 170, 100, - mapm)

  //apricot jam
  fill(240, 90, 26);
  rect(280, 170, 100, - maph)


  text("strawberry", 25, 225);
  text("raspberry", 160, 225);
  text("apricot", 300, 225);


I chose to use different jams as a representation of time. Strawberry jam sells more than the other two which is why I made it seconds. Raspberry sells faster than apricot which is why I made it minutes.

svitoora – 06 Looking Outward

Would you install a Facebook App that Randomly Deletes Your “Friends”?

Friend Fracker (2013) by Rafael Lozano-Hemmer is an API art that randomly unfriends 1-10 people on your Facebook account. I admire how such a simple algorithm based on randomness could help you reveal who your true friends are, and serves as a larger commentary on human relationships in the digital age. The algorithm is elegantly simple, randomly select 1 to 10 friends in your Facebook account, and delete them. Additionally, an added layer privacy is also added for Friend Fracker uses Facebook’s standard authentication and security service, therefore it doesn’t track your password nor private information. Your deleted friends wouldn’t know that you unfriend them, and neither would you.

alchan-Project 06-abstract clock

abstract clock

function setup() {
    createCanvas(240, 480);

function draw() {
  var m = month();
  var d = day();
  // map the current hour, minute, & second
  // to an r, g, or b value
  var hr = map(hour(), 0, 23, 0, 255);
  var min = map(minute(), 0, 59, 0, 255);
  var sec = map(second(), 0, 59, 0, 255);
  var clock = {r: min, g: sec, b: hr};

  // assign colors to minute and second
  // (hour is present in both as the blue value)
  var minColor = color(clock.r, 0, clock.b);
  var secColor = color(0, clock.g, clock.b);

  // draw gradient; the top color represents the minute
  // & the bottom represents the second
  // (hour is the blue value)
  for (var c = 0; c <= height; c += 5) {
    var amt = map(c, 0, height, 0, 1);
    var gradient = lerpColor(minColor, secColor, amt);
    rect(0, c, width, 5);

  // draw a number of equally spaced lines dependant on month
  // (the month is how many sections the area is divided into)
  // day of month is represented by the y position of the lines
  for (var i = 0; i <= m; i++) {
    var monthDiv = width / m;
    var dayPos = map(d, 0, 31, 0, height-10);
    rect(monthDiv + i*monthDiv, dayPos, 1, 10);

I played around with a few different ideas in my sketches (I thought about doing something related to lunar phases, a clock that represented time by randomly scattering dots on a grid, and a more representational clock that showed time by the growth of a flower).

I really wanted to create a clock that was abstract enough to almost be without a focal point, and decided to play around with color as a representation of time. I originally just had the r, g, and b values of the background assigned to the hour, minute, and second. This was a little boring for anyone who didn’t watch the clock for a long period of time, so I decided to play around with gradients and also incorporate the day and month

In the final clock, the top color represents the current minute, while the bottom color represents the current second. The hour is the blue value present in both colors. Month is represented by the number of divisions created by the white lines, and the y-position of the lines is roughly equivalent to the day of the month.

gyueunp – Looking Outwards 06

Nicholas Sassoon is a French-born artist who currently lives and works in Vancouver, Canada. He uses early computer imaging techniques to create his works that demonstrate the possibility of expressing dimensions of the physical realm through digital images.

Sassoon’s Drift is a work with an oddly celestial quality that captivated me. The random alterations of the elements create a fascinating effect that displays a sense of motion. Ultimately, the random movements of the visual elements create a simultaneously mesmerising and unsettling effect. They separate and merge together to create scenes of nature or those that convey a sense of narrative.  Additionally, the auditory element enhances the overall experience of the piece.


Nicholas Sassoon’s website



(Example of a minuet created by using Mozart’s K.516f.


Title: K.516f

Creator: Wolfgang Amadeus Mozart

Year of Creation: 1787

Link to the Article:                              http://www.pianonoise.com/Article.dice.htm  https://en.wikipedia.org/wiki/Musikalisches_W%C3%BCrfelspiel

Link to the Bio of the Artist: https://www.biography.com/people/wolfgang-mozart-9417115


K.516f is a minuet composed by Mozart in 1787 according to his own version of Musikalische Würfelspiele. Musikalische Würfelspiele (translated: musical dice game) describes any type of game / means of composing musical pieces that involves rolling one or more dices to randomly generate the notes or measures, and it was popular among the composers in the 18th century Europe. It was supposed to offer a fun alternative way of composing, even for the amateurs who were not familiar with the basic rules of composition. Its exact origin or inventor is unknown, but the very first example dates back to 1757, when Johann Philipp Kirnberger wrote Der allezeit fertige Menuetten- und Polonaisencomponist (German for “The Ever-Ready Minuet and Polonaise Composer”). Other famous versions include the ones by C.P.E Bach (J.S. Bach’s fifth son).

The most well-known version of Musikalische Würfelspiele and its product were published by Mozart in 1787. Composition K.516f included the instruction of the game and the pres-made measures to choose from.

Here’s how Mozart’s version works:

There are 176 pre-written measure to choose from if one is to compose a Minuet; 96 if Trio. Two six-sided dices are then rolled to determine which measure comes next. Using the instruction sheet, one could determine which dice roll corresponds to which measure put next.

It’s impressive how the composition sounds so put together and well thought-out even though the measures are randomly arranged. Maybe it’s just Mozart’s brilliance that he was able to compose individual measures that would sound coherent no matter how they are arranged.







 * Name | Ai Fukuda 
 * Course Section | C 
 * Email | afukuda@andrew.cmu.edu
 * Project | 06

function setup() {
    createCanvas(480, 300); 

function draw() {
    background(73, 106, 139);

    for (y=200; y<300; y+=20) {                // STAR 'TICKS' (BOTTOM LEFT OF CANVAS)
        fill(255, 248, 222);
        for (x=0; x<480; x+=10) {
            if (y%3 == 1) {                       // calling even rows 
                rect(2*x+270, y, 1, 7);
            else {                                // calling odd rows 
                rect(2*x+260, y, 1, 7);  
    push();                                   // SHOOTING STAR LINES 
        stroke(209, 226, 244);
        line(300, 20, 440, 25);
        stroke(206, 236, 236);
        line(300, 30, 440, 45);
        stroke(255, 248, 222);
        line(300, 40, 380, 58);

    push();                                  // SHOOTING STAR RECT  
        fill(209, 226, 244);
        rect(455, 26, 5, 5);
        fill(206, 236, 236);
        rect(460, 47, 12, 12);

    var s = second();
    var m = minute();
    var h = hour()%12;     // so hour is given in 12 (not 24)

        frameRate(40);                                 // defining speed            
        var step = frameCount % 40;
        applyMatrix(1, 0, 0, 1, 40+step, 50+step/3);   // defining slope of 'shooting star' motion 
        fill(255, 248, 222);
        rect(350, 8, 30, 30);

    // MINUTE 
    A = color(255, 250, 195); // light yellow 
    B = color(250, 241, 262); // yellow 
    C = color(254, 232, 147); // yellow yellow orange 
    D = color(255, 228, 183); // yellow orange 
    E = color(253, 205, 167); // orange 
    F = color(253, 210, 194); // orange pink 
    G = color(248, 202, 215); // pink 
    H = color(233, 208, 229); // light pink purple 
    I = color(204, 178, 213); // pink purple 
    J = color(182, 178, 215); // purple 

    interA = lerpColor(A, B, .5);
    interB = lerpColor(B, C, .5);
    interC3 = lerpColor(C, D, .33);
    interC6 = lerpColor(C, D, .66);
    interD3 = lerpColor(D, E, .33);
    interD6 = lerpColor(D, E, .66);
    interE3 = lerpColor(E, F, .33);
    interE6 = lerpColor(E, F, .66);
    interF3 = lerpColor(F, G, .33);
    interF6 = lerpColor(F, G, .66);
    interG = lerpColor(G, H, .5);
    interH3 = lerpColor(H, I, .33);
    interH6 = lerpColor(H, I, .66);
    interI3 = lerpColor(I, J, .33);
    interI6 = lerpColor(I, J, .66);
    // interH = lerpColor(H, I, .5);

        for (z=0; z<m; z++) {         // adding color gradient to minute spectrum                           
            translate(-8, 2.2);
            if (z<2) {              
            else if (z<4) {
            else if (z<6) {
            else if (z<8) {
            else if (z<10) {
            else if (z<12) {
            else if (z<14) {
            else if (z<16) {
            else if (z<18) {
            else if (z<20) {
            else if (z<22) {
            else if (z<24) {
            else if (z<26) {
            else if (z<28) {
            else if (z<30) {
            else if (z<32) {
            else if (z<34) {
            else if (z<36) {
            else if (z<38) {
            else if (z<40) {
            else if (z<42) {
            else if (z<44) {
            else if (z<46) {
            else if (z<48) {
            else {
            rect(480, 100, z/3, z);

    // HOUR 
    fill(186, 227, 247);
    translate(-92, -92);                                
    arc(100, 100, 300, 300, HALF_PI - radians(7.5*h), HALF_PI);   // shows pie according to hour 
} // end of draw function 

The design of my abstract clock is an abstraction of the solar system; with a shooting star indicating the seconds, the array of planets indicating the minutes and the degree of the sun visible indicating the hour of the current time. Although the different time units are represented distinctively, through the motion/ the flow of its directionality I tried to harmonize them better. One thing I would improve upon is the color gradation seen in the minutes; I feel like there is a much more efficient way to get the same affect.




13/9/65 Nr. 2 (Hommage à Paul Klee) 

13/9/65 Nr. 2 (Hommage à Paul Klee) by Frieder Nake is said to be one of the most frequently cited earliest phase of computer art (mid-1960s). I admire how the work plays with the fine line of whether it was hand-crated or computer-generated, which makes the work engaging and intriguing. According to Programm-Information PI-21 where Nake describes the processes involved in generating this artwork, he lists all of the random elements of this work: width of horizontal bands, “buckling” of horizontal bands from left to right, vertical lines of triangles, size (radius) of the circles. It is also intriguing that this piece of work contains numerous variables that are randomized, yet because of the constancy of the general ‘rules’ (having bands of horizontal rules with an array of vertical bands periodically, etc.), the artwork maintains its intention and does not seem utterly random.

Link | http://dada.compart-bremen.de/item/artwork/414

Work | Frieder Nake. 13/9/65 Nr. 2 (Hommage à Paul Klee). 13. 09. 1965