Week 12: Project Work, Check List

This week, you decide which day you will install, and where. Installation choices are:

  1. Wednesday Week 13, between 9am and 2pm
  2. Thursday Week 13, between 9am and 2pm

Tear down must occur on Friday afternoon after 2pm.

You must consider how your work will be installed:

  1. Artist statement (printed on A4 / A5 paper, pinned to wall?),
  2. attachments to wall: pins, nails, other,
  3. lighting (down lights, flood light, spot light, etc.),
  4. plinths (may need to be repainted),
  5. placement of computers / laptops on ceiling grid,
  6. hanging devices (from ceiling),
  7. video projection material. etc.

Please make sure that you have booked your equipment requirements with Glenn.

If you are working with digital files (video, audio, etc.) you must use the appropriate format (and provide Glenn with a USB or SD card .. he can lend you one):

  1. VIDEO: H264 (MKV or MP4). any resolution up to Full HD
  2. AUDIO: MP# or Vorbis

For (int i = 0; i <10,000; i = i +1) ... how many repetitions?

This week we continue with research and development of your final project. We have seen that using loops is a fundamental part of the materiality of computational media, and we ask you to consider this one very important question: If you are using a repeated process (or a ‘loop’) then how many repetitions will you need to achieve an aesthetic effect?

Part 1: Thinking about count of repetition

Consider the following works and estimate the repetitions used. Could these works have been done with less repetitions? Would these works be better with more repetitions?

Vera Molnar, 25 Carrès (25 Squares), 1989

Vera Molnar, 25 Carrès (25 Squares), 1989






Richard Long, Line Mae by Walking, 1967


Ai Wei Wei, Bang, 2010-2013, 886 antique stools, installation view, 2013

Is there a difference between repetition and simply large numbers of objects?


Ai Wei Wei, Sunflower Seeds, Tate Modern’s Turbine Hall, October 2010. 100.000.000 seeds, with a total weight of 150 tons.

“Like Ai Weiwei’s other works, ‘Sunflower Seeds’ is a work closely related to the society, politics and economy in China, and also a project that can be accomplished only in this country. It alludes to the globalisation and mass production in China that caters to western consumerism, and to the deemed insignificant element at the bottom of the production chain – thousands of cheap labors, assembly lines in gigantic factories, and tedious procedures. Absurdly, ‘Sunflower Seeds’ provided work for 1,600 artisans in Jingdenzhen, a fact that is an ironic reflection of the social reality. “(http://www.aiweiweiseeds.com/about-ai-weiweis-sunflower-seeds, accessed 10/2015)

Triple Elvis 1962 Acrylic silkscreened on canvas

Triple Elvis 1962 Acrylic silkscreened on canvas

Some ideas about exploring social media: http://www.fubiz.net/2014/04/07/emoji-nation/ (note that these don’t explicitly involve repetition)

Part 2: Presenting to Peers

Document your work and present it to a peer. Your peer’s role is to critically engage your work, that is: criticise it with a view of improving it.

Your presentation should follow the assessment guidelines:

  1. How is your work informed by artists / artists works / theorists. Peer should question if the references are sufficiently reputable and adequate.
  2. What is the basic rule or process that the work engages in. In other words, are you sure that it is a computational media work? What is being abstracted into instructions?
  3. What new insight or aesthetic is exposed with your rule or process? Peer should identify whether the work actually does this for someone who hasn’t heard the verbal argument.
  4. How will you execute and present your work. Peer should identify how they think the execution and presentation might go wrong.

Part 3: Documenting work development

Create another blog post on your personal Blog, documenting any development of your concept.

You might include:

  • Found images
  • mock ups (perhaps done in photoshop)
  • word maps highlighting key words and concepts
  • idea maps
  • drawings (scanned or photographed and uploaded)


Week 11: Finding Forms to Abstract

This week focus on analysing computational works by asking ourselves:

  1. What has been abstracted?
  2. What do the procedures/instructions look like?
  3. What final form has those instructions given rise to?
  4. What is the fit between the source of the abstraction, and the result of the abstraction?


Analyse the work of:

  1. Richard Long27.-Richard-Long
  2. Antony Gormley
  3. BREATHING ROOM II[Antony Gormley, [1]Breathing Room III, 2010]
  4. [Maya Lin, Systematic Landscapes, 2009]

  5. [Lucas Samaras, Chair Transformation Number 20B, 1996]

  6. [Andy Warhol, Campbell’s Soup Cans, 1968] 54



Week 10: Abstract over video, or sound

This week we continue our exploration of what is possible by writing instructions to create works. This time, we use video, or sound. And we start thinking and documenting ideas for the final MEDA102 project.

As we have already seen, Sol LeWitt abstracts a visual idea into instructions.

Abstracting an aesthetic idea is only one way to use instructions to create art works. Another way is to abstract a process into instructions. The artwork is then created using this process. The process itself is generative of the work’s material, but may not abstract (or capture) any aesthetic judgement.

Maria Merz’s work: A Real Sum is a Sum of People (1972) in which a series of photos is taken following the order of the Fibonacci series is one example of a work in which the instructions define a process, not an aesthetic. If a group of people were to execute one of LeWitt’s wall drawings, each work would be very similar. If a group of people were to execute Merz’s rules they may come up with very different works.

The question we ask today, is what works might be possible if we use instructions to define a process that involves video or sound?

One example of such a work is Erica Scourti’s ‘My Life in Adwords’, already discussed in lectures. What is the realm of meaning of Scourti’s work?

Are there possibilities for new and exciting works in the video-rich social media platforms we use everyday?

What is the relationship between the instructions that Scourti has generated and the resultant realm of meaning of her work?

Analysis 1

What is Erica Scourti doing in the below work? What is her process? What is the realm of meaning that she is addressing?

Analysis 2

Discussion: how might the execution of a set of instructions hold meaning in a work?

One way that instruction-based processes have been used in art is through iteratively copying a work. The below works explore this process. That is, copies are made of the original work over and over again. Each time a copy is made, it is degraded. Here, what is being abstracted is a process that iteratively changes a work.

  • What are the effects?
  • What thoughts do they inspire in the audience?
  • What do these processes say about the technologies used and our relationship to them?

Alvin Lucier, I am sing in a room, 1969

Canzona, I am sing in a room, 2010

William Raben, 2’45”, 1973



These exercises are designed to help you explore possibilities for your final assignment. As you go through them, document your research as a blog post. Post the URL to the blog post as a comment to this page.

Exercise 1: Instagram feed.

Examine your Instagram account. Choose one of your images which you find particularly engaging (for any reason). Document the process that led up to the creation of the photo. Ask yourself: what would happen if this process was repeated 40 times? What realm of meaning might come out?

Exercise 2: Research scholarly articles

Go to scholar.google.com. Search “rule based art”. Filter through the results for any interesting cues and suggestions about processes. Add additional search terms to refine the search to creative art. Document.

Exercise 3: SnapChat stories.

Examine your SnapChat ‘stories’ feed (if you use SnapChat). Document a video that you feel exposes something personal about the person who submitted it. Translate that video into a set of rules. Execute those rules yourself.

How might you use SnapChat as a video platform to create a work? How would you capture those videos? Does capturing SnapChat videos break the platform?

Exercise 4: LearningToLoveYouMore

Go through the ‘assignments’ on this website: http://www.learningtoloveyoumore.com/

Choose one ‘assignment’ (there are 70 documented), such as “Photograph a scar and write about it.” Execute the assignment yourself, document the results. Explore and document how you might expand this rule to create your own work.

Exercise 5: Iterative destruction (or creation)

In the spirit of the analysis exercise above, define a process that will, iteratively, change or destroy a work. For example:

  1. Choose a photo you took last weekend, write a comment that describes how you felt when it was taken
  2. Ask a friend to replicate the photo as closely as possible
  3. Ask another friend to replicate the replication
  4. Repeat 10 times
  5. Publish the last image on your blog, with your original comment describing how you felt when the original photo was taken.

Exercise 6: Research Erica Scourti’s other works

Explore Erica Scourti’s website: http://www.ericascourti.com/. Examine 3 of her other works. Document whether they can also be considered rule-based-works.

Exercise 7: Document your own ideas

There are various ways that you might start capturing and testing ideas. You might:

  • abstract a particular aesthetic directly,
  • abstract a process that generates a work, without concern to the final aesthetic and without concern with what is produced,
  • abstract a process that generates many possibilities and choose just one of those generated possibilities as your final work (this is how much digital generative art is produced)


To use sound in Processing requires the installation of extra sound processing libraries. Importing Sound libraries is easy on Processing V3, and more involved in Processing V2 (the version supplied in the computer labs). This document pertains to Processing V3 (so you will have to download and run V3 on the lab desktops, or use your own machine).

To install these go to Sketch > Import Library > Library. Search for “Sound” and choose the item that reads “Sound | Sound library based on MethCla for Processing”. Click “Install”.

Next, try the below code to test the sound library installation.

import processing.sound.*;
SinOsc sine;

void setup() {
  size(640, 360);
  // Create the sine oscillator.
  sine = new SinOsc(this);

void draw() {

Once the sound library installation is working try the following exercises:

  • Use a loop to create a sweeping sine tone (from a low frequency; 20 Hz, to a high frequency; 10000 Hz)
  • correlate the drawing of shapes with specific tones

Explore the examples at https://processing.org/reference/libraries/sound/

Week 9: Abstract over photography

In this week’s workshop, we explore what happens when instructions are used to abstract forms and processes over another medium: photography.

We analyse the work of a few photographers and attempt to break down their work as abstractions expressed in instructions. Again, our primary endeavour is one of abstracting an idea. And this involves 2 things:

  1. Judging what it is that needs to be abstracted; which essential aspect of a photo or the process of taking a photo is responsible for its aesthetic life?
  2. Working out how to capture those essential characteristics into instructions.

For example: observe the below photograph by Bill Henson.

Artist : Bill Henson (Australia, b.1955) Title : Date : 1985-1986 Medium Description: type C photograph Dimensions : Credit Line : Hallmark Cards Australian Photography Collection Fund 1988 Image Credit Line : Accession Number : 70.1988

Artist : Bill Henson (Australia, b.1955)
Date : 1985-1986
Medium Description: type C photograph

Possible abstraction:

Take a photo of an urban context on a bright sunny day. Underexpose the photo so much that it looks like dusk.

‘The Creek’
The Edge, 2013
© Tamara Dean
‘The Edge’ is an exploration of the informal rites of passage created by young people in relationship with the natural world. The initiations, the pushing of physical, spiritual and emotional limits in order to discover one’s sense of self.

Possible abstraction:

In an empty landscape, take a photo of someone walking into a dark bush

Shaun Gladwell

Possible abstraction

Put a human mask on inanimate object. Take a photo of it lying down.  

Exercise 1: To abstract, distil!

Your tutor will provide you with an image by one of two Australian photographers: Jordan Madge and Marcus Andersen. Analyse the image and reduce it to its singular key visual idea. This idea might be:

  • compositional
  • textural
  • spatial
  • tonal
  • etc.

IMPORTANT: Do not try to replicate the photo. Identify the key visual idea, and translate *that* to a 1 sentence instruction.

Once you have written your 1 sentence instruction, swap with another student. Execute each others’ instructions then discuss.

Exercise 2: Choose your own image

Step 1: Explore the photography of these Australian photographers

  • Bill Henson
  • Justien Varga
  • Marcus Andersen
  • Tamara Dean
  • Tracey Moffatt
  • Matthew Abbott
  • Jordan Madge
  • Shaun Gladwell
  • Henri Mallard
  • Michael Riley

Step 2: Choose a single photograph that you think you can abstract into instructions. Write those instructions on a piece of paper.

Step 3: Share those instructions with another student.

Step 4: Document the photos that are the result of the instructions you wrote.

Exercise 3: Analysis

Analyse the below works (some were discussed early on in lectures).

  • Identify the key ‘rule’ that is used to generate each work
  • Research the artists’ intent, describe their thinking
  • How has the presentation of the work augmented the rules defined
  • How do these rules differ from Sol Lewitt’s style rules?
Image result for ed ruscha all blocks on sunset boulevard

Ed Rusha, Every Building on the Sunset Strip (1966)

Image result for Mario Merz Fibonacci 1202

Mario Merz, Fibonacci 1202


Image result for Gary Hill’s Conundrum

Gary Hill, Conundrum, 1995

Image result for Mel Bochner’s 36 Photographs and 12 Diagrams

Mel Bochner, 36 Photographs and 12 Diagrams, 1966

Exercise 4: Ad Lib Instructions

Now, invent your own instructions without taking any cues from existing photos. Again, swap with another student, execute and discuss the results.

Examples might be:

  • Take 16 photos that each has a strong horizontal line exactly in the middle of the image. Organise in a 4×4 grid.
  • Take 10 photos, each of a different red car
  • Take a photo of every part of your body that is not clothed
  • Take 10 photos, each separated by a count of minutes defined by the Fibonacci sequence (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …)
  • Take a photo of the face of someone you don’t know
  • Turn your exposure up 3 or 5 stops. Take a photo of a shadow.

Coding (Using Images)

Processing actually makes it very simple to include and manipulate images into your sketch. You might try going through the following tutorial: https://processing.org/tutorials/pixels/

Or play with the following code. Note, you’ll need to put this image on your Desktop first:


Screen Shot 2015-09-16 at 2.51.56 pm

// this next line loads up the image.
// It is a complicated way of saying "get the image from my desktop".
PImage sunflower = loadImage(System.getProperty("user.home") + "/Desktop/tint1.jpg");
void setup(){

void draw(){
   tint(255,100); // this makes the image transparent
   for (int i = 0; i < 100 ; i ++) {

Week 8: Perlin Noise – an uncanny algorithm

Perlin Noise, an algorithm invented by movie special effects researcher Kevin Perlin, has an unparalelled capacity to create forms that are intrinsically organic. In this Workshop we explore its possibilities.


This below work, by early computer artist Manfred Mohr, was not generated using Perlin noise. Can you see how it was made?

“Zerreissprobe”, black nylon stocking on cardboard, 1960, 35cm x 50cm, Private Collection, Germany © 1960 by Manfred Mohr

Understand Perlin Noise

Perlin Noise is a fractal order. That is to say, it is an order in which self-similarity is exhibited at different scales. However, instead of the self-similarity being a line or a shape, it is in the amount of randomness.

So if you have the same amount of randomness at different scales like this:

 float x = random(1) + random(10) + random(100) + random(1000);

Here you have the basis for Perlin Noise. Another key characteristic of Perlin Noise is that neighbouring values have a relation to each other. This is a bit like a wave motion, where a wave is made up of values that have a relation to the neighbouring value.

In the image below, notice how each wave is randomised at different scales? Perlin Noise simply involves summing up each of these waves to achieve the wave shown at the bottom.

In the image below, a 3D wave is randomised. The image on the left shows a randomisation at only 1 scale. In the middle image, its randomness is applied at two different scales. In the third image, three different scales. Notice how the third image starts to exhibit characteristics that appear very similar to real-world landscapes?

Perlin Noise


Find an example of Perlin Noise and see if you can understand exactly what might be being randomised at different scales.

You might try searching in:

  • graphic design
  • art
  • film special effects
  • computer game design

Can you find a use of Perlin Noise that doesn’t involve a visual element?

Processing Code Samples

In the below code a grid of random circles are drawn in a grid. Execute the code on your own computer and make sure that you understand everything by commenting each of the lines.

What do you notice about the randomness of the circles? They have no relation to each other!

void setup(){
 background(255); size(800,600); 
 strokeWeight(0.4); noFill(); 

void draw() {
 float radius = 0;
 for (int i = 0 ; i < 800 ; i = i + 20){
  for (int j = 0 ; j < 600 ; j = j + 20){
   radius = random(20);
   ellipse(i,j, radius, radius);

Processing has already ‘abstracted’ Perlin Noise for us. That is to say, Processing makes it very easy for us to use Perlin Noise simply by calling a function:

noise(float x, float y);

x and y can be simply as the coordinates of a map.

Be careful! … the above function will always return a value between 0 and 1. In other words, it is very likely that you will need to multiply the results of the noise function by some other value to bring it into a usable range.

Now, copy and paste the below code into your computer and see how the random circles have taken on a very different character. Now, the randomness of each circle is tied to the value of the circles next to it.

void setup(){
 noFill(); strokeWeight (0.4);

float radius, resolution = 180;

void draw() {
 for (int i = 0 ; i < 800 ; i = i + 20){
  for (int j = 0 ; j < 600 ; j = j + 20){
   radius = noise(i / resolution, j / resolution) * 30;
   ellipse(i,j, radius, radius);

Comment the above lines of code until you understand what each line does.

What else might you drive using Perlin Noise? You could try:

  • line thickness
  • colour variations
  • opacity
  • different shapes sizes
  • circle location instead of circle size
  • etc.

What would happen if we were to try to draw polylines, where each point was varied using Perlin Noise? Try the below code:

void setup() {
 size(800, 600); background(255);
 noFill(); strokeWeight (0.1);

float perlinResolution = 400;

void draw() {

for (int lineCount = 0; lineCount < 600; lineCount = lineCount + 4) {
  for (int i = 0; i < 800; i = i + 4) { 
   vertex( i, noise( i / perlinResolution, lineCount / perlinResolution) * 600 );

Other resources to understand Perlin Noise

Noise, flows and generative art

Continue Iterating on your project

Remember that successful creative practice is driven by a pattern of iterative development. In other words, the best way to create engaging visual designs is to continually explore, changing small aspects of your design, always observing the produced result independently from your intentions!


Week 6: Sharing Functions

This week, we play with other people’s functions, and we write functions that other people will play with.

In so doing, you will become acquainted with one of the most powerful aspects of Computational Media: the ease with which instructions can be bundled up and sent elsewhere… or, the ease with which you can incorporate other people’s instructions into your own code.

This characteristic has broad political, social and economic implications.



Think about the implications of

  1. Parts of your code being used in other people’s code
  2. Your code using other people’s code

Spend 15 minutes researching on the Internet, and establish what might be the political, social, economical implications of shared sets of instructions?

Step 1: Use someone else’s function

Start with a basic sketch such as the one below. In this sketch, a grid of 10 by 10 circles is drawn.

void setup(){

void draw(){
 for (int i = 20 ; i < 400 ; i = i + 40){
  for (int j = 20 ; j < 400 ; j = j + 40){
   ellipse(i,j, 30,30);

Now, copy and paste the below ‘function’ and call it instead of calling the ‘ellipse’ command above.

 * This function draws a target.
 * It takes 2 parameters (x and y) which define
 * the position of the target that is drawn.
 * x: the distance in pixels from the top left
 * y: the distance in pixels from the top right 
void drawTarget(float x, float y) {
  for (int i = 0; i < 50; i = i + 5) {
    if (i%2 == 0) { // this line says "if i is an even number then..." 
      fill(255);    // fill in white
    } else {        // otherwise
      fill(0);      // fill in black
    ellipse(x, y, 50 - i, 50 - i);

At first try to make something interesting with that function without changing it. Then, allow yourself to change it.

What do you notice about using someone else’s function?

  • is it easier / more difficult than writing your own?
  • what are the advantages?
  • what are the limitations?
  • would it be acceptable to you change the function and call it your own?
  • do you think it would be right to reference the original author of this function?

Step 2: Now roll your own.

Now, spend some time playing exploring what kinds of patterns might make an interesting function for others to use. You might want to go back and have a little bit of an explore of the early computer artists work.

Invent / design a function that results in the drawing of graphic primitives on the screen. Make sure that your function encapsulates some kind of visual idea.

Make sure that:

  1. You offer some parameters to the end user. You might offer:
    1. x and y locations (or i and j in the above example),
    2. colour choices,
    3. size choices,
    4. size of random variation,
    5. etc.
  2. You document what the code does (in clearly written english) what the function does,
  3. Your function encompasses a clear visual idea.

Step 3: Upload your code to a code-sharing website

  1. Upload your code to https://gist.github.com/
    1. make sure that you choose the right syntax highlighting (by giving a filename that ends with .java)
  2. Copy the URL of your code
  3. Post the URL of your code as a comment on this webpage.

Step 4: Grab two other people’s code

  1. Go to the medadada function sharing blog post
  2. Grab 2 other people’s functions (copy paste into your own Processing sketch)

Step 5: Make an artwork (using other people’s functions), and post it to your blog.

Now that you have all the code in your sketch, you can explore the functions. Make an artwork that uses these functions in your own way. Try to avoid changing the function (just for the sake of this exercise).

Step 6: Modify downloaded code, then make another artwork, and post it to your blog.

Step 7: Analysis

Analyse how others have used your work, and comment on the following:

  1. Was your ‘visual idea’ used as you had anticipated?
  2. Do you think the user has improved or reduced your graphic vision?
  3. etc.

Week 5: Functions (as encapsulated abstractions)

This week we shift our thinking from instructions written for humans to instructions written for computers. But we retain our aesthetic focus!

P-103, "visual pythagoras", series of four plotter drawings, ink on paper, (4 x) 40cm x 40cm, 1972

Manfred Mohr, P-103, “visual pythagoras”, series of four plotter drawings, ink on paper, (4 x) 40cm x 40cm, 1972

Exercise 1: Observe ‘what works’

Research the following artists and make a list of forms, orders, patterns, techniques etc. that seems to suit computationally executed visual ideas:

  • Vera Molnar
  • Manfred Mohr
  • Georg Nees
  • any other ‘early computer artist’
  • any ‘American Minimalist’
  • etc.

For example, some abstractions that work well in computational media are:

  1. Many, millions, of fine lines creates lots of complexity which works well to engage the eye.
    Screen Shot 2017-07-13 at 4.16.55 pm
  2. Working with different line thicknesses creates a fine engineering drafting aesthetic (not unlike some of Lewitt’s work).
    IMG_9112s Lewitt’s ‘Quadrangle’ drawing (1974)
  3. Using overlapping shapes of different opacities
    Vera_Molnar_Quadrate_hauskonstruktiv_15_likeyouVera Molnar: 9 carrés rouges, 1991

Identify 3 aspects of the early computer artists works that are consistently visually engaging, and present to class.

Exercise 2: Coding (Program logic and Forks)


Have a look at this flowchart closely. This is the well-known flowchart The Art of Asking your Boss for a Raise created by French writer Georges Perec. The flowchart also exists as a book and a chapter in  Life. A User Manual (it may be interested to look at how the instructions exist in words).  See http://www.theartofaskingyourbossforaraise.com/ for an interactive version of the flowchart.

See whether you can identify the following in the instructions:

  1. 3 objects
  2. 3 methods (or functions)
  3. 3 loops
  4. a start point
  5. 3 end points
  6. 3 forks

How to write a Fork

Familiarise yourself with the syntax for “if” conditions. as it is documented in the below two links.



if ( /* this is true */) 
  // do what is coded here
} else {
  // do what is coded here

Exercise 3: Coding (Functions, called by Loops)

This week, your aim is to re-create Vera Molnar’s work below, and to incorporate a function call into that implementation.

To do this, you will need:

  • a grid (a loop within a loop, or nested loop)… see last week’s code.
  • a function that draws a shape and handles the variation on that shape.

Vera Molnar 144 Trapèzes (144 Trapeziums) 1974 computer graphic, open series, 16

What is a Function?

A function is a bunch of code, that has a name. When that name is called, all the instructions defined in that bunch are called. For example: the function goShopping() might look like this:

void goShopping() {
  // drive to shops
  // chose things to buy
  // pay for them
  // drive home

To use the goShopping() function you can call it from anywhere in your code … like this:

void goAboutMyDay() {

Functions can do 2 special things:

  1. they can have parameters
  2. they can ‘return’ values.

For example, lets say I would like to limit how much money I want to spend, then I can pass-in a budget parameter as such:

void goShopping(int budget) {
  // drive to shops
  // chose things to buy under total budget
  // pay for them
  // drive home

Now lets say that I don’t find anything that I want to buy … then we can define a ‘return’ parameter

int goShopping(int budget) {
  // drive to shops
  // chose things to buy under total budget
  // pay for them
  // drive home
  return thingsIBought; // might be 5, 6, 12

The aim of returning this parameter is that I can then use it in my program logic:

if ( goShopping() < 1) {
  // I didn't buy anything!

Step 1: Switch to dynamic mode.

To write and make use of functions we have to switch to what is called the dynamic mode. In this mode we ned to define 2 functions: setup() and draw(). These two functions separate the code that is called once and only once (at the beginning of execution), and the code that will be called over and over again.

Here is basic code in static mode, that is to say, without the setup() and draw() functions:



And now here is the *same* code wrapped up in the two basic necessary functions:

void setup(){
 noLoop();   // this just makes sure that 
             // <draw> is called only once

void draw(){

Now lets go through the exercise (repeating the Vera Molnar work above) blow by blow.

Step 1: Make a loop

Using previous workshop’s code, or your own saved code, make a loop (a single loop, that repeats any one instruction 1000 times).

Step 2: Draw a random line with the loop

Within your loop, create a random line. Remember that the syntax is:

line(x1, y1, x2, y2);

For a random number, the syntax looks like this (this line produces a random number between 10 and 70).

random(10, 70);

Step 3: Place the random line drawing code into a function

Make sure that this function is called within your main loop.

void drawRandomLine() {
     // draw random line here

Now change the function in some way to test that it is being properly used. You might choose just to change the colour of the line.

Step 4: Include a parameter into the function

Choose a parameter to include into your function. You might choose one of the following:

  • a different colour
  • a different line thickness
  • one of the lines’ x or y points

In the below example, I define the starting x and y position of the line

void drawRandomLine(int x, int y) { 
  line(x, y, random(400), random(400));

Step 5: Make a grid (loop within loop)

Now lets place our code within a grid (a nested loop). Here’s the basic syntax of a grid:

for (int i = 0 ; i < 400; i = i + 20) {
  for (int j = 0 ; j < 400; j = j + 20) {
    // draw something here
    line(i, j, 200,200);

Replace the ‘line’ command above with your special function.

At this point you should be able to create 144 Trapeziums in its entirety. Hint: use a PShape to create the trapeziums.

Step 6: Special challenge: Change the colours by calling an ‘if’ condition.

Try to change the colours of a small group of the trapeziums. Maybe make 5 or 6 trapeziums print in red. How would you do that? You might use an if condition such as the below:

if ( random(100) < 2) {
  // make colour red
} else {
  // make color black

Step 7: Rotating elements (for the game)

Rotating elements is quite difficult in Processing: it is one of the few command syntaxes that doesn’t seem intuitive or well thought out. Have a look at the below code … feel free to play around incorporating this into your work.

translate(100, 100);
rect(0, 0, 80, 20);


If you are feeling *super* game

If you are feeling very game you might attempt to replicate the below work by Vera Molnar. It contains rotations… but the tricky question is does she manage to create *areas* of missing lines? Can you uncover the logic required to produce those?

Vera Molnar, 'Interruptions,' 1968

Vera Molnar, ‘Interruptions,’ 1968



Week 4: Assignment Work

A turn towards materials

Sol Lewitt: Wall Drawing #47

As discussed in the lecture, Lewitt argues that “Conceptual Art” is first and foremost an act of intuition. Just as Lewitt intuited that areas of differing pencil intensity, achieved through cross-hatched lines, would make a visually engaging work, we ask:

What is the best way to use the materials we have specified by our instructions?

Last week we discovered that certain visual patterns may be interesting, but perhaps more importantly, we discovered that the way the drawing is executed has a significant impact on how those patterns come to life.

Pencil lines drawn too softly, work poorly centred on the page, border margins too small, sheet of paper too crumpled. These kinds of executions can inhibit the successful reception of a work. This week, we focus on specifying qualities of execution.

Assignment work

Exercise 1: Analysis.

Review 6 different sets of instructions written by Lewitt. Examine which portion of the instructions define materials and how to use them as opposed to defining visual patterns or orders.

Note your research and present to class.

Exercise 2

Make a list of all the possible materials you might use in your assignment. For example:

  • ink?
  • pencil?
  • paint?
  • torn paper?

Then make a list of all the ways in which these materials might be poorly executed. For example:

  • drawing insufficiently centred
  • folds evident when they should not be there
  • ink pen too light
  • ink pen too heavy
  • pencil lines hairy (sketchy)
  • pencil lines too straight (drawn with ruler when shouldn’t have been)
  • pencil lines too wobbly (should have been drawn with pencil).

These ideas should then be included in your definition of instructions.

Instruction Iteration

Review the instructions you wrote last week, and re-iterate at least twice.

Coding (if time)

Examine the below plotter drawings by Vera Molnar from the series: (Dés)Ordres, 1974.

  • Identify why you think they are visually rewarding piece.
  • what are the representations that they make, what do they remind you of, what do they look like?

Identify how the work was produced:

  • how many shapes are there in each unit?
  • how are they varied?
  • are there many different line thicknesses?

Then … choose one and reproduce it in Processing!

You might start by simply copying the below code,

// draw a window that is 600 x 600 px
// make sure it has a white background

// This is known as a 'nested loop'
// It involves creating a loop within a loop
// The outer loop copies items across to make a row
// the inner loop copies the row down to make a grid
for(int i = 0; i < 600 ; i = i +20){
  for(int j = 0; j < 600 ; j = j +20){
    // Here is a rectangle ...try changeing this line!
    rect(i , j , 18, 18);


Week 3: Art as Instructions


Making of Sol LeWitt’s Wall Drawing #797 at the Blanton Museum of Art

The idea becomes a machine that makes the art.”

Sol LeWitt

In Week 3’s workshop, we explore the practice of rule-based-art. We research known artists working in this modality, we execute some works, and we have a go at producing our own rules.

Research & Analysis

Find 3 artists who were creating ‘Rule Based Work’ or who belong to the movement known as American Minimalism’ in the 1960’s, 1970’s and 1980’s . Identify one of each of their works, and note down the rule / rules used to generate the work.

Then note:

  • Most importantly: Why you think the work is successful … the visual idea, the pattern, the combination of colours etc.
  • The name of the artist, the name of the work, the year
  • Write down the rule that they have created (if it is a rule based work)
  • Find photographic documentation (if it exists)
  • Aesthetic value: Write down the possible realms of meaning that the work delves into. You may have to do a little bit of research to identify these.

I you are stuck trying to identify what the meaning us about, you might try following these simple guidelines:

  1. Write a list of all the representations that are made in the work
  2. Write down a list of all the questions that the work poses (i.e. the questions that enter your head when you are trying to work it out).

As a start, you might have a look at Lewitt’s work documented here: http://archive.fo/OAesu

3 Exercises (executing instructions)

1. Rule-based paper sculpture

(Idea taken from here: https://chloedraper.wordpress.com/2011/10/13/rule-based-art-2/)

  1. Draw a square, 6cm x 6cm
  2. Add a triangle (of any shape/size) to the side of a square
  3. Add a square to that triangle
  4. repeat steps 2 and 3 six times
  5. Cut the shape out
  6. Fold along every second line
  7. fix together (into 3D shape) using tape


2. Knots in 3’s

(from https://www.conditionaldesign.org/workshops/knots/)

In a group of 3, with 3 different coloured textas: do the following (see the video above)

  1. Elongate your line on both sides by looping it over and under a line of another colour.
  2. You may not loop your own line or the line you looped in your last turn.
  3. If you have no options left on one of the sides, that side is dead.
  4. When both sides are dead, you may place a new line.

(explore the other works at https://www.conditionaldesign.org/archive/)

Kaleidoscope: this is another interesting work from this site (https://www.conditionaldesign.org/workshops/kaleidoscope/)

3. Algorithmic drawing

  1. Draw 9 cubes (your best cubes, doesn’t matter how messy) in a grid of 3 by 3 on a sheet
  2. Shade in a different side on each cube. (only 3 cubes will be shaded … you can only see 3 sides of a cube!)
  3. Draw many parallel diagonal lines from the edge of the sheet … start at the top left corner (more or less) and progress towards the bottom right hand corner. Do not cross a cube. If you hit a cube, stop the line.
  4. Continue until a large part of the page is covered in diagonal lines

Writing instructions

Create 3 of your own instruction based works that are informed by the research and analysis exercise you completed earlier.

Ask yourself:

  • which visual forms seem to be the most engaging,
  • which visual forms manage to make a broad range of representations
  • why?

Create your own set of instructions, pass them onto 2 other people who will then execute them.

Repeat twice.


Examine the below plotter drawings by Vera Molnar from the series: (Dés)Ordres, 1974.


  • Identify why you think they are visually rewarding piece.
  • what are the representations that they make, what do they remind you of, what do they look like?

Identify how the work was produced:

  • how many shapes are there in each unit?
  • how are they varied?
  • are there many different line thicknesses?

Then … choose one and reproduce it in Processing!