Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
34
void setup(){
size(400, 400);
background(255);
noStroke();
float myColor = getRandomColor();
fill(myColor);
rect(width/4, height/4, width/2, height/2);
}
float getRandomColor(){
return random(255);
}
The program still draws a rectangle on the white background, but instead of the rectangle
always being black, the program calculates a random value between white and black for
the fill color of the rectangle. The line return random(255); generates and returns a random
number between 0 and 255. 0 equals black and 255 equals white, and anything in
between equals a variation of gray. You’ll notice the program now has these strange brackets,{
(open) and } (closed). These are called curly braces, and they are used to group the
lines of code needed by the function to do its job. You’ll also notice that the program is
broken into two groups of code: void setup(){...} and float getRandomColor(){...}.
These groups are both functions. The lines void setup(){...} and float
getRandomColor(){...} are the function declarations. It is a good idea to use a verb in
the name to describe what the function does. That way, it is easy to understand what that
function’s job is when reviewing the code. Also, a function is followed by open and closed
parentheses. This is the place where any arguments (values) the function will need to do
its job are included—commonly referred to as “passing arguments.” Even if no arguments
are required, as in the preceding case, you still need to include the parentheses.
There is another very common programming structure called a variable, which I’ll discuss
in detail a little later in the book. A variable is simply a location in memory that will hold a
piece of data. For instance, in the left part of the expression float myColor =
getRandomColor();, float myColor is a variable, to which a numeric value can be
assigned. The word “float” just specifies the type of numeric value the variable can hold.
The line float myColor = getRandomColor(); is a function call. Actually, the right part of
the expression, getRandomColor();, is the function call, and the left part of the expression
(float myColor =) simply assigns the value that the function call returns to the myColor
variable. Here’s where things get a little interesting. When the getRandomColor() function
is called, it takes over—before the line below the function call (fill(myColor);) is dealt
with, the code inside the actual getRandomColor() function is run. Only when the function
called finishes will the code below the function call be run. Inside the getRandomColor()
function, one of Processing’s built-in functions, random(), is called. Once the random()
function does its job, it returns a number back to where the getRandomColor() function
was called from, and this returned value is assigned to the variable float myColor. I realize
this may seem a bit overwhelming if this is your first time dealing with coding; I promise
it will make (more) sense over time.
OOP was developed later than function-based or procedural programming, and was
designed to try to improve on some of procedural programming’s perceived limitations.
In a general sense, OOP was designed to allow the types of modules that functions