October 2020 – Page 34 – [OLD FALL 2020] 15-104 • Introduction to Computing for Creative Practice

Looking Outwards 06: Randomness

For this blog post, I chose to examine Mozart’s Musikalisches Würfelspiel which was a waltz created by chance. What I found so interesting about this waltz was how it showed that it’s hard to create something from pure chance but that it took some knowledge and methodology on the composers part. Essentially, without the knowledge behind what parts go into a waltz, Mozart’s piece would not have been so successful. The roll of a die was not meant to determine a random note – instead they corresponded to pre-composed portions of a waltz that were then pieced together by the chance of a dice.

Normally, I would not look into music since I have very limited music knowledge. However, I came across an article that “coded” Mozart’s waltz through computer generated chance and I found it really interesting how I was able to see/visualize the waltz through code.

Project-06

sketch



function setup() {
    createCanvas(480, 480);
    background(220);
    text("p5.js vers 0.9.0 test.", 10, 15);
}

function draw() {
	background(0, 150, 250); //sky blue
	var s = second();
	var m = minute();
	var h = hour();
	var d = day();
	noStroke();

	//water
	fill(0, 0, 230); //water blue
	rect(0, 180, 480, 220);
	//waves
    for (var a = 0; a <= width; a = a+1) {
    	for (var b = 200; b <= 450; b = b+50) {
    	stroke(0, 0, 150);
    	strokeWeight(1);
    	point(a, b - 15 * sin(radians(a)));	
        }
    }
    fish(200, 250);
    fish(400, 300);
    fish(60, 275);
    
    //sand
    noStroke();
    fill(170, 100, 20) //darker brown, shows up as water receeds
    rect(0, 380-h*2, 480, 400);
	fill(185, 122, 40); //lighter brown with dots in the sand
	rect(0, 380, 480, 120);
	for (var sx = 20; sx <= width; sx = sx+40) {
		for (var sy = 400; sy <= height; sy = sy + 40) {
        stroke(223, 182, 112); //lightest brown
        strokeWeight(3);
        point(sx, sy);
		}
	}
	for (sx = 40; sx <= width; sx = sx + 40){
		for (sy = 420; sy <= height; sy = sy + 40){
			point(sx, sy);
		}
	}
	crab(s*8, 440);
	sun(m*8, 70);
	cloud(400, 50);
	cloud(50, 75);
	boat(d*13, 170);

}


function crab(x, y) {
	push();
	translate(x, y);
	noStroke();
	fill(230, 0, 0);
	ellipse(0, 0, 30, 20);
	fill(255);
	ellipse(-8, -9, 5, 5);
	ellipse(8, -9, 5, 5);
	fill(0);
	ellipse(-8, -9, 3, 3);
	ellipse(8, -9, 3, 3);
	stroke(230, 0, 0);
	strokeWeight(4);
	line(-10, 5, -25, 20);
	line(10, 5, 25, 20);
	line(-15, 0, -25, 5);
	line(15, 0, 25, 5);
	pop();
}

function fish(x, y) {
	push();
	translate(x, y);
	noStroke();
	fill(225, 0, 225); //light purple
	ellipse(0, 0, 30, 15);
	triangle(15, 0, 25, -10, 25, 10);
	fill(255);
	circle(-8, 0, 5);
	fill(0);
	circle(-8, 0, 3);
	pop();
}

function sun(x, y) {
	push();
	translate(x, y);
	noStroke();
	fill(255, 255, 0);
	circle(0, 0, 45);
	stroke(255, 150, 0);
	strokeWeight(7);
	line(30, 0, 50, 0);
	line(-30, 0, -50, 0);
	line(0, 30, 0, 50);
	line(0, -30, 0, -50);
	rotate(radians(45));
	line(30, 0, 50, 0);
	line(-30, 0, -50, 0);
	line(0, 30, 0, 50);
	line(0, -30, 0, -50);
	pop();

}

function boat(x, y) {
	push();
	translate(x, y);
	noStroke();
	fill(185, 122, 40); //main sand brown
	arc(0, 0, 60, 60, 0, PI, CHORD);
	rect(-5, -50, 5, 50);
	fill(255);
	triangle(0, -50, 0, -10, 30, -10);
	triangle(-5, -50, -5, -10, -30, -10);
	pop();
}

function cloud(x, y) {
	push();
	translate(x, y);
	noStroke();
	fill(240);
	circle(0, 0, 45);
	circle(25, 10, 25);
	ellipse(0, 20, 75, 20);
	pop();
}

I made this based on a beach scene. The crab moves across the sand with the seconds, the sun moves across the sky with the minutes, the water recedes with the hours, exposing the darker brown (wet) sand below it. The boat moves based on the day.

Project 06 – Aquarium Clock

For this project, I was inspired by the week’s lab. At first, I thought it would be simple to convert the fish code to a clock but this was not the case. I had to play around with the arrays and indexes to make everything work. The number of fish represent the minutes as well as the level of water. The color of the water represents the hour of the day to show the tank getting dirtier until it is finally cleaned. Lastly, the clam opening and closing represents seconds.

sketch Download

var x = [];
var y = [];
var dx = [];
var c = [];
//var numFish = minute()
function setup() {
    createCanvas(480, 480);
    background(220);
    //stores values for 59 fish in an array
    for (var i=0; i<59; i++) {
        //random x position for fish array
        x[i] = random(50, width-50);
        //y position so fish will only be spawned within the water
        y[i] = 3/4*height-i*((5/12/60)*height)
        //random speed of the fish
        dx[i] = random(-5, 5);
        //random color of the fish
        c[i] = color(random(255), random(255), random(255));
    }
}

function draw() {
    //variables to keep track of time
    var s = second();
    var h = hour();
    var m = minute();

    background(220);
    stroke(0);

    //fish tank with water level
    //creates background rectangle of water based upon the hour
    fill(0, 255, 255-(75/23)*h);
    rect(10, 1/4*height, width - 20, 3/4*height)
    //matches the background color and shrinks to reveal more water
    fill(220);
    rect(10, 1/4*height, width - 20, 1/3*height-(1/4*height/60)*m);
    //creates fish
    //creates the number of fish based upon minutes (+1 fish each minute)
    //resets to zero fish every hour
    for (i=0; i<m; i++) {
        fish(x[i], y[i], dx[i], c[i]);
        x[i] += dx[i];
        //makes the fish turn within the aquarium
        if(x[i] >= width - 25) {
            dx[i] = -dx[i]
        } else if(x[i] <= 25) {
            dx[i] = -dx[i]
        }
    }
    //sand
    fill(237, 201, 175);
    rect(10, 410, width-20, height-405);
    //open and closes the clam every second (logic is based upon even/odd
    //seconds)
    if(s%2 == 1) {
        openClam();
    } else {
            closedClam();
      }

}
//used two functions to open and close clam
function closedClam() {
    fill(199, 176, 255);
    //top half of clam
    arc(385, 400, 70, 30, PI, 0, CHORD)
    //bottom half of clam
    arc(385, 400, 70, 30, 0, PI, CHORD);
    noStroke();
    //back of clam
    quad(430, 410, 430, 390, 410, 400, 410, 400);
}

function openClam() {
    fill(255);
    //creates the pearl
    circle(390, 400, 20);
    fill(199, 176, 255);
    push();
    //allows for rotation around back of clam
    translate(420,400)
    //rotates the top half of the clam
    rotate(radians(30));
    //top half of clam
    arc(385-420, 400-400, 70, 30, PI, 0, CHORD)
    pop();
    //bottom half of clam
    arc(385, 400, 70, 30, 0, PI, CHORD);
    noStroke();
    //back of clam
    quad(430, 410, 430, 390, 410, 400, 410, 400);
}

//creates the fish based on the following parameters
function fish(x, y, dx, c){
    //fills fish with the color from the array
    fill(c);
    //initial position of the fish based on the array
    ellipse(x, y, 20, 10);
    //logic for whether the fish tail is on the right or left side of fish
    if(dx >= 0) {
        triangle(x - 10, y, x - 15, y - 5, x - 15, y + 5);
    }
    else if(dx < 0) {
        triangle(x + 10, y, x + 15, y - 5, x + 15, y + 5);
    }
}

LO 6 – Randomness in Art

Artist: Dane Clark
Project: Coding Architecture 2: Randomness Project

I admire the project because while it was created with randomness, the values were stored to create a repeatable art piece. The artist described his piece as appearing random, but it was in fact a pre-conceived final product. It is interesting to show many of the random possibilities then the selection of the actual element. This was done through different shading and opacities. The artist described the randomness as the appearance of many different possibilities and through deletion and rearrangement the creation of the final product. The algorithms showed the many possibilities of randomness, but the algorithms all led to the planned out piece. The artistic sensibilities are shown through the dynamic movement and flow of the piece. Additionally, the scaling and connection between the opacity of pieces add to the art. The most interesting aspect is the “revealing” of the possible randomness. For each additional branch several possibilities are shown, but only some are added before the next branch is created. The project shows that while some things may appear random, they are in fact not at all.

http://lostritto.com/risd2015spring-seminar/?p=255

Abstract Clock

sketch.6.sl Download

// Sarah Luongo
// Section A

// This code aims to tell time via a buttefly, with the body filling to blue every second, purple dots being added every minute, and the background changing every hour.

var r = 12;
var g = 16;
var b = 30;

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

function draw() {
    // Background changes different shades of blue every hour
    H = hour();
    // Black - medium blue from 12 AM - 7 AM
    if (H<8){
        background(r*H, g*H, b*H);
    // Medium blue - light blue from 8 AM - 4 PM
    } else if (H >= 8 & H <= 16) {
	background(r*H, g*H, 245*H);
    // Light blue - dark blue from 5 PM - 11 PM
    } else {
        background(192 - (r+13)*(H-16), 255 - (g+20)*(H-16), 255 - b*(H-16));
    }

    translate(width/2, height/2);
    // Pink wings for the butterfly
    fill(255, 50, 123);
    butterflyW();

    // Body of the butterfly
    fill(0); // Black
    ellipse(0, 0, 6, 100);

    // Body filling to a blue color every second
    fill(120, 150, 160);
    var S = map(second(), 0, 59, 0, 100);
        ellipse(0, 0, 6, S);

    // Purple dots added every minute
    fill(75, 0, 110);
    rotate(radians(45));
    for (var j = 0; j < minute(); j++) {
	// Bottom right wing
	if(j <= 15) {
	    circle(j*12+13, 0, 10);
	// Top left wing 
	} else if(j <= 30) {
	    circle(-(j-15)*12-7,0,10);
	// Bottom left wing
	} else if (j <= 45) {
	    rotate(radians(90));
	    circle((j-30)*12+7,0,10);
	    rotate(radians(-90));
	// Top right wing
	} else {
	    rotate(radians(90));
	    circle(-(j-45)*12-7,0,10);
	    rotate(radians(-90));
	}
    }
}

function butterflyW() {
    var da = PI/100;
    beginShape();
    for (var i = 0; i <= 2*PI; i += da) {
	var w = sin(2*i) * width/2;
	var x = w * cos(i);
	var y = w * sin(i);
	vertex(x, y);
    }
    endShape(CLOSE);
}

I wanted to do a butterfly to tell time for this project because I was inspired by one of the many faces on my apple watch. Also, I used to love catching butterflies when I was younger (and letting them go of course). I think there are a lot of beautiful butterflies out there. I would’ve like to do a more exquisite butterfly, but I felt it was better to try and have the assignment requirements down before designing anything too crazy. I was happy to at least show a little design to the butterfly with the addition of purple dots every minute.

LO 6 – Randomness

Kenneth Martin was an English artist who mainly created non-representational/abstract art using geometric shapes. Martin drew inspiration from the work of Kasimir Malevich and Alexander Calder, interested in exploring spatial relationships between simple structural elements.

“Chance and Order” (1971) is one of my favorite pieces by Martin, and I think that his process of creating this artwork is quite fascinating. Randomness played a significant role in producing the final work, yet his approach was very organized and systematic, hence the name “Chance and Order” which describes his process and method. I found the following explanation regarding his process for the “Chance and Order” series of work: “The points of intersection on a grid of squares are numbered and the numbers are written on small cards and picked at random…A line is made between each successive pair of numbers as they are picked out” (Understanding Uncertainty).

I admire the simplicity of Martin’s work and find that while his pieces only utilize basic graphic/geometric elements, they are still very visually intriguing.

Chance, Order, Change 6 (Black) 1978-9
More about Martin’s process

Project : 06

sketch

/*Aadya Bhartia
Section A 
abhartia@cmu.edu*/

//initializing arrays to hold x and y position of candy based on hours 
var candyX = [0,0,25,-25,-8,43,-42,15,-21,40,-45,6,12];
var candyY = [0,47,40,40,18,18,18,12,2,-5,-10,-15,-20];
var minX = 90;
var minY = 90;
var secX = 260;
var secY = 380;
var hr = 0;

function setup() {
    createCanvas(500, 500);
    background(255, 217, 206);
}
function draw() {
	background(255, 217, 206);
	var s = second();
	var m = minute();
	var h = hour();
	var angle = 0;
	var secR = s/60;
	var minR = m/60;
	//seconds 
	fill(139, 170, 173,90);
	noStroke();
	ellipse(secX, secY, 177*secR); //circle increasing in size for seconds
	stroke(64, 78, 92);
	strokeWeight(1/20*s);
	noFill();
	arc(secX,secY,200, 200, 0 , 2*PI * secR);
	stroke(146, 55, 77);
	strokeWeight(1/6*s); //stroke gets thicker based on seconds
	noFill();
	arc(secX,secY,184, 184, 0 ,2*PI * secR);
	fill(221, 117, 150);
	noStroke();
	rect(secX+82,secY-8,200,10); //bar for seconds 
	//minutes 
	fill(221, 117, 150);
	noStroke();
	rect((minX-3),(minY +62),6,400);//base for the candy ball to count minutes 
	push();
	noFill();
	strokeWeight(1/5*m);
	stroke(113, 10, 53);
	translate(minX,minY);
	ellipse(0, 0, 140); //base for the candy ball to count minutes
	stroke(0);
	strokeWeight(1);
	//hour
	hr = h%12; // number of candy in the ball count the hours 
	candy(hr);
	pop();
	//minutes counted with hearts in a 6 by 10 grid 
	var ctr = [];
	var counter = 0;
	for(var i = 0;i<60;i++){ //creating an array to store all possible minutes 
		ctr.push(i);
	}
	for(var x = 1;x<7;x++){
		for(var y = 1;y<=10;y++){
			push();
			translate(320,8);
			if(counter == m){
				fill(255); //white colour for current minute 
				heart(25*x,25*y);
			}
			else{
				fill(221, 117, 150,random(100,200));
				heart(25*x,25*y);
			}
			pop();
		counter+=1;
		}
	}
}
//candy helps count the hours 
function candy(hr){
	for(var j = 1; j<=hr;j++){//candy globe effect given by the predefined array counting the hours
		fill(random(100,200),random(0,50),random(20,70));
		ellipse(candyX[j],candyY[j],35);
	}
}
function heart(minX,minY){ //creating hearts which count the minutes 
	ellipse(minX-4,minY,9);
	ellipse(minX+4,minY,9);
	triangle(minX-8,minY+2,minX+8,minY+2,minX,minY+10)
}

For this project, I decided to create something which had elements of a candy store the seconds are calculated through the circle on the bottom right, the minutes by the candy globe shell and by the hearts while the hours are shown through the number of candy balls in the globe.

Looking Outwards : 06

Perlin noise was created by Ken Perlin in 1983 for a film he was working on, Tron. 35 years ago, Ken Perlin won an academic award for discovering the technique now called “Perlin Noise.” Perlin noise is described as a type of gradient noise that interpolates random values to create smooth transitions through the noise function. It helped him add randomness to CG renderings of natural elements like smoke, fire, and water. Its flexibility in mathematical expressions allowed perlin noise to be used to create a wide variety of textures that imitate the controlled random appearance of textures in nature.

In our architecture studio under Dana Cupkova, we are exploring randomness using keyshotand other rendering tools such as grasshopper and kangaroo and it was extremely interesting to read about a similar concept but in a different perspective altogether. I was extremely inspired by how random yet sophisticated his textures look and surprised that something computer generated could still have that level of detail. In real life we take textures like this for granted and do not realise the amount of work that goes into creating smooth transitions.

Project 06 – clock

Hi friends!! For those that don’t know me very well, I spend a lot of time talking about astrology. Instead of making a clock that tells the time per say, I made a clock that tells the current astrological sign in the ascendant, which changes every two hours. I know it’s not exactly the same goal as the project but look at my symbols for each sign! I spent so long making them!!

sketch Download

//To quickly explain, I'm making a clock for astrological rising signs in the Libra season (right now)
//Rising signs change every 2 hours
var x;
var y;
var h;

function setup() {
    createCanvas(100, 650);
    background(255);
    text("p5.js vers 0.9.0 test.", 10, 15);
}

//symbols for eahc of the signs
function aries(x, y) {
	strokeWeight(3);
	beginShape();
	curveVertex(x, y);
	curveVertex(x, y);
	curveVertex(x + 10, y - 16);
	curveVertex(x + 25, y + 32);
	curveVertex(x + 40, y - 16);
	curveVertex(x + 50, y);
	curveVertex(x + 50, y);
	endShape();
}

function taurus(x, y) {
	strokeWeight(3);
	beginShape();
	curveVertex(x, y);
	curveVertex(x, y);
	curveVertex(x + 25, y + 16);
	curveVertex(x + 50, y);
	curveVertex(x + 50, y);
	endShape();
	noFill();
	circle(x + 25, y + 32, 32);
}

function gemini(x, y) {
	strokeWeight(3);
	line(x, y, x + 50, y);
	line(x + 15, y, x + 15, y + 40);
	line(x + 35, y, x + 35, y + 40);
	line(x, y + 40, x + 50, y + 40);
}

function cancer(x, y) {
	strokeWeight(3);
	beginShape();
	curveVertex(x, y);
	curveVertex(x, y);
	curveVertex(x + 25, y - 5);
	curveVertex(x + 50, y);
	curveVertex(x + 50, y);
	endShape();
	beginShape();
	curveVertex(x, y + 35);
	curveVertex(x, y + 35);
	curveVertex(x + 25, y + 40);
	curveVertex(x + 50, y + 35);
	curveVertex(x + 50, y + 35);
	endShape();
	circle(x + 10, y + 7, 20);
	circle(x + 40, y + 28, 20);
}

function leo(x, y) {
	strokeWeight(3);
	beginShape();
	curveVertex(x, y);
	curveVertex(x, y);
	curveVertex(x - 10, y - 20);
	curveVertex(x + 10, y - 24);
	curveVertex(x + 20, y - 20);
	curveVertex(x + 10, y + 20);
	curveVertex(x + 20, y + 18);
	curveVertex(x + 20, y + 18);
	endShape();
	circle(x - 10, y, 20);
}

function virgo(x, y){
	strokeWeight(3);
	line(x, y, x, y + 40);
	beginShape();
	curveVertex(x, y + 5);
	curveVertex(x, y + 5);
	curveVertex(x + 10, y);
	curveVertex(x + 10, y + 40);
	curveVertex(x + 10, y + 40);
	endShape();
	beginShape();
	curveVertex(x + 10, y + 5);
	curveVertex(x + 10, y + 5);
	curveVertex(x + 20, y);
	curveVertex(x + 20, y + 40);
	curveVertex(x + 25, y + 45);
	curveVertex(x + 25, y + 45);
	endShape();
	beginShape();
	curveVertex(x + 20, y + 15);
	curveVertex(x + 20, y + 15);
	curveVertex(x + 35, y + 10);
	curveVertex(x + 15, y + 45);
	curveVertex(x + 15, y + 45);
	endShape();
}

function libra(x, y) {
	strokeWeight(3);
	line(x, y, x + 50, y);
	beginShape();
	curveVertex(x, y - 10);
	curveVertex(x, y - 10);
	curveVertex(x + 15, y - 10);
	curveVertex(x + 10, y - 30);
	curveVertex(x + 25, y - 40);
	curveVertex(x + 40, y - 30);
	curveVertex(x + 35, y - 10);
	curveVertex(x + 50, y - 10);
	curveVertex(x + 50, y - 10);
	endShape();
}

function scorpio(x, y) {
	strokeWeight(3);
	line(x, y, x, y + 40);
	beginShape();
	curveVertex(x, y + 5);
	curveVertex(x, y + 5);
	curveVertex(x + 10, y);
	curveVertex(x + 10, y + 40);
	curveVertex(x + 10, y + 40);
	endShape();
	beginShape();
	curveVertex(x + 10, y + 5);
	curveVertex(x + 10, y + 5);
	curveVertex(x + 20, y);
	curveVertex(x + 20, y + 40);
	curveVertex(x + 25, y + 45);
	curveVertex(x + 30, y + 40);
	curveVertex(x + 30, y + 40);
	endShape();
	triangle(x + 28, y + 38, x + 32, y + 42, x + 31, y + 36);
}

function sag(x, y) {
	strokeWeight(3);
	line(x, y, x + 30, y - 40);
	line(x + 5, y - 30, x + 30, y - 10);
	line(x + 15, y - 40, x + 30, y - 40);
	line(x + 30, y - 40, x + 40, y - 25);
}

function cap(x, y) {
	strokeWeight(3);
	beginShape();
	curveVertex(x, y);
	curveVertex(x, y);
	curveVertex(x + 5, y + 20);
	curveVertex(x + 10, y);
	curveVertex(x + 15, y - 5);
	curveVertex(x + 20, y);
	curveVertex(x + 20, y + 35);
	curveVertex(x + 15, y + 40);
	curveVertex(x + 15, y + 40);
	endShape();
	circle(x + 30, y + 30, 20);
}

function aqua(x, y) {
	strokeWeight(3);
	line(x, y, x + 10, y - 5);
	line(x + 10, y - 5, x + 15, y);
	line(x + 15, y, x + 25, y - 5);
	line(x + 25, y - 5, x + 30, y);
	line(x + 30, y, x + 40, y - 5);
	line(x + 40, y - 5, x + 45, y);
	line(x, y + 20, x + 10, y + 15);
	line(x + 10, y + 15, x + 15, y + 20);
	line(x + 15, y + 20, x + 25, y + 15);
	line(x + 25, y + 15, x + 30, y + 20);
	line(x + 30, y + 20, x + 40, y + 15);
	line(x + 40, y + 15, x + 45, y + 20);
}

function pisces(x, y) {
	strokeWeight(3);
	line(x, y, x + 50, y);
	beginShape();
	curveVertex(x, y - 20);
	curveVertex(x, y - 20);
	curveVertex(x + 15, y);
	curveVertex(x, y + 20);
	curveVertex(x, y + 20);
	endShape();
	beginShape();
	curveVertex(x + 50, y - 20);
	curveVertex(x + 50, y - 20);
	curveVertex(x + 35, y);
	curveVertex(x + 50, y + 20);
	curveVertex(x + 50, y + 20);
	endShape();
}

function draw() {
	//aries(25, 18);
	//taurus(25, 50);
	//gemini(25, 105);
	//cancer(25, 160);
	//leo(50, 235);
	//virgo(33, 260);
	//libra(25, 350);
	//scorpio(35, 360);
	//sag(33, 460);
	//cap(35, 470);
	//aqua(27, 530);
	//pisces(25, 580);
	//when we are in the range of this ascendant, the color of the symbol and the background reflects the element of that sign
	h = hour();
	if (h >= 0 & h < 2) {
		background(255, 54, 54);
		stroke(175, 0, 0); //fire is red
		leo(50, 235);
	} else if (h >= 2 & h < 4) {
		background(54, 255, 54);
		stroke(0, 175, 0); //earth is green
		virgo(33, 260);
	} else if (h >= 4 & h < 6) {
		background(150, 255, 255);
		stroke(0, 222, 222); //air is crystal blue
		libra(25, 350);
	} else if (h >= 6 & h < 8) {
		background(107, 107, 255);
		stroke(0, 0, 212); //water is royal blue
		scorpio(35, 360);
	} else if (h >= 8 & h < 10) {
		background(255, 54, 54);
		stroke(175, 0, 0);
		sag(33, 460);
	} else if (h >= 10 & h < 12) {
		background(54, 255, 54);
		stroke(0, 175, 0);
		cap(35, 470);
	} else if (h >= 12 & h < 14) {
		background(150, 255, 255);
		stroke(0, 222, 222);
		aqua(27, 530);
	} else if (h >= 14 & h < 16) {
		background(107, 107, 255);
		stroke(0, 0, 212);
		pisces(25, 580);
	} else if (h >= 16 & h < 18) {
		background(255, 54, 54);
		stroke(175, 0, 0);
		aries(25, 18);
	} else if (h >= 18 & h < 20) {
		background(54, 255, 54);
		stroke(0, 175, 0);
		taurus(25, 50);
	} else if (h >= 20 & h < 22) {
		background(150, 255, 255);
		stroke(0, 222, 222);
		gemini(25, 105);
	} else {
		background(107, 107, 255);
		stroke(0, 0, 212);
		cancer(25, 160);
	}
}

LO Randomness

The randomness artist I will be talking about is Merce Cunningham. Merce Cunningham was a 20th century choreographer who devised his pieces through chance alone. Some of his techniques included prescibing numbers on a die to certain dance moves and created sequences by rolling the die an amount of times. He also often would teach his dances without any music, to allow that to be a random variable separate from the performers’ abilities to do the dance. The dancers would only hear the music for the first time on the day of the performance. Merce Cunningham was wild, I loved how his work centered making dance accessible for all. I see his techniques of chance and randomness as avenues for anyone to choreograph, which I admire greatly. As you can see in the piece that I am linking, “Beach Birds for Camera,” from 1993, the way he devised his pieces allowed for asynchronous and repeated movement from the performers, contributing to his unusual but distinctive style.