This project prompt reminded me of the lofi compilations and streams on Youtube, especially chilledcow’s iconic homework girl and her cat, who is perpetually doing her homework. I decided to make myself as the homework girl, depicting a similar image of me working at my desk on my projects and homework.

//hollyl
//sonic story
//section D

var imgWrite;
var imgLight;
var imgType;
var imgSaw;

var sndWrite;
var sndLight;
var sndType;
var sndSaw;

var timer = 0;

function preload(){
	//images
	imgWrite = loadImage("https://i.imgur.com/lnbABjC.jpg");
	imgLight = loadImage("https://i.imgur.com/TD2n1MK.jpg");
	imgType = loadImage("https://i.imgur.com/uE8friX.jpg");
	imgSaw = loadImage("https://i.imgur.com/M3GU9Yx.jpg");

	//sounds
	sndWrite = loadSound("http://localhost:8000/writing.wav");
	sndLight = loadSound("http://localhost:8000/light.wav");
	sndType = loadSound("http://localhost:8000/typing.wav");
	sndSaw = loadSound("http://localhost:8000/saw.wav");
}

function soundSetup(){
	sndWrite.setVolume(1);
	sndLight.setVolume(1);
	sndType.setVolume(1);
	sndSaw.setVolume(1);
}

//sounds go brr
function saw(){
	sndWrite.stop();
	image(imgSaw, 0, 0);
	sndSaw.play();
}

function write(){
	image(imgWrite, 0, 0);
	sndWrite.play();
}

function type(){
	sndSaw.stop();
	image(imgType, 0, 0);
	sndType.play();
}

function light(){
	sndType.stop();
	image(imgLight, 0, 0);
	sndLight.play();
}

function setup() {
    createCanvas(600, 410);
    frameRate(1);
}

function draw(){
	if (timer < 4){
		write();
	} else if (timer <= 8){
		saw();
	} else if (timer <= 12){
		type();
	} else if (timer <= 13){
		light();
	} else if (timer > 13){
		sndLight.stop();
		fill(0);
		rect(0, 0, 600, 410);
	}
	timer++;

	text("click for audio", 10, 20);
}

My clip shows my workflow: sawing some pieces for a product’s project, sketching out my notes and thoughts before starting my 104 project, and then clicking my light off when I finish. Hours of work and mess condensed into a seconds long clip that makes my work look a lot tidier than it actually is.

Anders Lind‘s work in sound art is both one of the physical and the computational. One of his notable projects, Lines, explores the relationship between the artist, the medium, and the viewer.

In Lines, Lind built instruments of sensors, where a viewer engaging with the marked lines in different ways would create sounds of different pitches and tempos. The three iterations (wall, floor, and ceiling) all follow the same basic principle-audience interaction with the lines create audio feedback.

I think that this exhibit could very easily be explored in the context of performance art and dance. Like in my last LO, this exhibit could be used to study motifs within the choreography, making the music and performance one and the same.

From Bennett’s LO – 04 on Tomu Tomu’s “Plant Sounds” project:

I really like the idea of being able to hear plant sounds. I like to think that everything makes noise, it’s just the matter of being able to hear it, like how when in a really quiet space or after working out you can hear your own body working, your inhale and exhale, your pulse, your blood running through your body. I guess plants don’t actually make noises, but I think that synthesizing certain noises to specific biological processes of the plant would be interesting. I think it would actually be an interesting exploration of tracking a plant’s growth or health. Assuming that certain processes are only for producing a new growth–maintaining current growths, cutting off nutrients from certain areas of the plant(like flowers on a plant dying), or trying to heal from damage or fight off infection–the general sounds produced by the plant would change according to what processes it’s engaging in, so you would be able to tell if the state of the plant is undergoing change prior to any visible change simply by the change in the sound produced. Although I think that would be far more complicated to create.

The “Plant Sounds” project reminds me of a product I saw a while ago: Playtronica. It’s a TouchMe Midi that faciliates the production of sound when an electronic loop is formed, essentially making it so that when two people form hold either end of the midi, they are able to create music through touching each other. I think the Playtronica has a lot of potential for experimentation, especially when used for performance or music production. I would be really interested in seeing a dance performance where the dances have individual midis with a specific set of notes/sounds per performer so that the sounds are explicitly created by the interaction of touch between specific dancers. I wonder if that were applied to a longer performance, like a ballet, you would be able to find motifs within the created music that tracks the interactions and grown of relationships between certain characters of the ballet.

Playtronica TouchMe: https://shop.playtronica.com/touchme

Sara Hendren is an artist, researcher, and professor based in Cambridge, Massachussetsin Colledge of Engineering. She is a self-described “humanist in tech” who focuses on the human body and the politics of disability.
My interest in Hendren was spark because of my current studies in design; the major requires us to take design theory/research classes that include design for equity and inclusivity. Design for disability is something that has been discussed in passing and seeing Hendren’s work focused on research and design for disability is a wonderful way to see disability-focused work outside of the classroom.
I particularly enjoyed seeing her project on dancing wheelchair ramps, a project constructing a series of ramps into a stage for Alice Sheppard to dance on. The project was worked on in collaboration with a physics class to study and work with the ramp’s affordances for choreography.
Sara’s presentation takes us not from an idea to a finished product, but the opposite, showing us the final project, and slowly working backward to its inception.

//hollyl
//composition with curves
//section D
var nPoints = 150;

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

function drawCartiod(){
	var x;
	var y;

	var a = 15;
	var b = a/2;
	var h = constrain(mouseY/50, 0, b);
	var ph = mouseX/50;

	fill(200, 255, 200);
	beginShape();
	for(var i=0; i<nPoints; i++){
		var t=map(i, 0, nPoints, 0, TWO_PI);

		x = (a+b)*cos(t) * (h-cos(ph+t*(a+b)/b));
		y = (a+b)*sin(t) * (h-cos(ph+t*(a+b)/b));
		vertex(x, y);
	}
	endShape(CLOSE);
}

function draw(){
	background(255);
	push();
	translate(width/2, height/2);
	drawCartiod();
	pop();
}

I really enjoyed the examples for this project, as they were very soothing to play with, so I decided to create a form that I enjoyed the most. I played around with epicycliod forms in desmos until I landed on one that I enjoyed that coded it.

I particularly enjoyed the recommended Chris Harrison‘s ColorFlower project, where he ran 16,276 data points of known and named colors and organized them by their hue to create rainbow visualizations. Harrison had to play a hand in helping the algorithm determine the difference between brown and red, etc. He also used an aspect of randomization to make the visualizations seem more organic and textural.

I was inspired by the idea of the lunar cycles and the moon’s effect on the oceans for this project.

//hollyl
//abstract clock assignment
//section D

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

function h(){								//hour wave
	var x = hour()*20;
	var y = width/2;
	noStroke();
	fill(58, 63, 139);
	rect(x-120, y/2, 240, y/2);
	ellipse(x, y/2, 120, y);
	rect(0, y, 480, y);
	fill(30, 30, 75);
	arc(x-120, y/2, 120, y, 0, PI);
	arc(x+120, y/2, 120, y, 0, PI);
}

function mn(){								//minute wave
	var x = minute()*8;
	var y = 180
	noStroke();
	fill(58, 91, 139);
	rect(x-90, height/2, y, y/2);
	ellipse(x, height/2, 90, y);
	rect(0, 330, 480, y);
	fill(58, 63, 139);
	arc(x-90, height/2, y/2, y, 0, PI);
	arc(x+90, height/2, y/2, y, 0, PI);
}

function s(){								//second wave
	var x = second()*8;
	var y = 120;
	noStroke();
	fill(59, 104, 172);
	rect(x-(y/2), 330, y, y/2);
	ellipse(x, 330, y/2, y);
	rect(0, height-90, 480, 90);
	fill(58, 91, 139);
	arc(x-(y/2), 330, y/2, y, 0, PI);
	arc(x+(y/2), 330, y/2, y, 0, PI);
}

function draw(){
	background(30, 30, 75);
	h();
	mn();
	s();
	fill(54, 146, 169);						//remnants of the millisecond wave that
	rect(0, height-45, 480, 45);			//moved way too fast
}

Notes:

An artist I follow, Geoffrey Bradway, creates computational art that is randomly generated through AI. Most of his work is a series of layered repetitive lines that create dynamic and fluid images, but other works include generated works that are based on other artists.

His process is writing software that utilizes ML to generate the patterns that are then drawn using his plotters.

var f = 10;
var l = 80;
var x = 0;
var y = 0;

function setup(){
	createCanvas(600, 553);
	background(232, 225, 197);
	angleMode(DEGREES);
}

function draw(){
	for(var i = 0; i <= 12; i += 1){
		x = 60*i;
		if(i % 2 == 0){
			y = 35;
		} else {
			y = 0;
		}
		for(; y <= 600; y += 69){
			push();
			translate(x, y);
			vine();
			flower();
			leaf1();
			leaf2();
			pop();
		}
	}
}
function vine(){
	noFill();
	stroke(132, 217, 143);
	strokeWeight(2);
	arc(-l/2, 0, l, 36, 0, 60);
	arc(l/2, 0, l, 35, 180, 240);
}

function leaf1(){
	noStroke();
	fill(153, 219, 190);
	arc(0, 0, l, l, 180, 240, CHORD);
	arc(((-3 * l)/2), 0, l, l, 0, 61, CHORD);
}

function leaf2(){
	angleMode(DEGREES);
	noStroke();
	fill(173, 219, 169);
	arc(0, 0, l, l, 60, 120, CHORD);
	arc(0, 0, l, l, 240, 300, CHORD);

}

function flower(){
	noStroke();

	fill(230, 145, 172);														//petals round
	circle(f, 0, f);
	circle((f/2), ((-f * sqrt(3))/2), f);
	circle((-f/2), ((-f * sqrt(3))/2), f);
	circle(-f, 0, f);
	circle((-f/2), ((f * sqrt(3))/2), f);
	circle((f/2), ((f * sqrt(3))/2), f);

	triangle(0, 0, f, 0, (f/2), ((-f * sqrt(3))/2));							//petals fill
	triangle(0, 0, f, 0, (f/2), ((f * sqrt(3))/2));
	triangle(0, 0, (f/2), ((f * sqrt(3))/2), (-f/2), ((f * sqrt(3))/2));
	triangle(0, 0, (-f/2), ((f * sqrt(3))/2), -f, 0);
	triangle(0, 0, -f, 0, (-f/2), ((-f * sqrt(3))/2));
	triangle(0, 0, (-f/2), ((-f * sqrt(3))/2), (f/2), ((-f * sqrt(3))/2));

	fill(247, 219, 0);															//pollen
	circle(0, 0, f);
}

I based the draw code off of the hexagon assignment since most of the initial wallpaper designs I had sketched had either hexagonal or octagonal bases. Although I had wanted to do a different(but similar!) wallpaper design, trying to get certain shapes to rotate and land in the correct placement stumped me. I fully intend on trying to fulfill my original design at a later date, but I’m happy with what I’ve done for now. Images of my notes from this project below.

One of my favorite places to explore and browse art is on Behance, an Adobe site that’s partially a job search site, partially a portfolio site, and an all-around great place to find great art. One of my favorite artists is Roman Bratschi, a 3D designer whose rendered art is filed with textures and materials that captivate the eye.

I think because I am a materially oriented person, anything with strong texture, even if it’s just the image of it, captivate my eye. Bratschi creates amazing textures in his renders that I can’t even begin to describe, and his use of vibrant and contrasting colors gives a lot of appeal to the images a well. As far as I am aware, the renders are generated through 3D software that allows for the user to tweak and adjust the form, texture, color, the density of said texture, almost anything imaginable to create renders. In its final form, Bratschi dictates the composition and generation of the art, even though he is using pre-programmed tools to help him create the images.