In researching this project I became fascinated by the simplicity in some artists work using computational media and repetition. A simple pattern can be just as intriguing as a complex image. The first piece that captured my attention was Frieder Nake’s Walk-Through-Raster, series 7.1, 1966 (as shown below). Nake uses this simple idea of repeated squares to create this almost grid like pattern. Following along from this idea was the introduction to Vera Molner’s Squares. This piece too shows the simplicity within the programming to create an interesting artwork. The grid like pattern reminded me of a city from above and was the first inspiration to my own creation. By first experimenting with the code for Vera Molnar’s Squares I developed an idea through the work’s use of iteration.

My own creation is dynamic compares to the two pieces I was most inspired by. However I feel this better represents my ideas behind the piece. The layered squares, which I created through a constant loop, continue to pile up upon one another endlessly. The squares are also arranged in a grid pattern. This together forms what I view as a constantly changing and building city. By altering certain aspects within my sketch I was able to refine it until it matched my image of a growing city.

Screenshot of Dynamic Image: Coding:

```<pre>
//int is a float and these stand seperate to create efficiency in the rest of the code
int cols=12;
//cols stands for columns which when drawn on later in the function will be equal to twelve
int rows=12;
//this float will be drawn upon later in the function and will be equal to twelve

//a semi colon is a statement terminator

void setup() {
//a function that runs once at the beginning of the setup
//curly braces define the beginning of a function block

size(600, 600);
//the size of the canvas, namely 600 pixels by 600 pixels
background(150);
//the colour of the background, in this case, a shade of grey
//noLoop(); if this were on the draw would run once however it is more effective if off
}

void draw() {
//a function that is called endlessly in a loop
delay(70);
//slows down each new step in the drawing process depending upon the length of the delay
rectangles();
//the name of the object I will draw later
rectMode(CENTER);
//this ensures that each new rectangle forms from the centre coordinates of the shape
}
void rectangles() {
//the function I will draw
fill(120,85);
//the first number within the brackets sets the shade of grey and the second number, the transparency
for (int i=0; i<cols; i++) {
//a for loop controls the repetition of an object
//if i is equal to zero, it is less than the number of columns stated at the top of the code
//if i is less that cols then you add one, hence i++
for (int j=0; j<rows; j++) {
//if j is equal to zero, it is less than the number of rows stated at the top of the code
//if j is less than rows you add one, hence j++

rect(20+(i)*(width/cols+1), 20+(j)*(width/rows+1), (int)random(50), (int)random(50));
//the rectangle (or rect)is constructed from (x coordinate, y coordinate, width, height)
//(int)random() allows for a random rectangle up to 50 pixels in width and height to be created
//each rectangle will begin at point (20,20) and then be added to i which is stated in the for loop
//this is then multiplied (using the asterisk) by the width of my shape divided by cols or rows +1
//ther term width is drawn from the later float in my rectangle
//this allows me to create a grid pattern
}
}
}
//curly braces define the ending of a function block
</pre>```

Screenshot of Sketch: 