Processing: Creative Coding and Computational Art

It’s because strict typing helps create more precise and ultimately faster-running code. If
you try to assign a float value—for example, 3.2—to int ballCount, Processing will spit
back a compiler error that says
The type of the right sub-expression, "float", is not assignable to
the variable, of type "int".
This may seem obnoxious and a royal pain, especially if you are used to a loosely typed
language, but it really is a useful (or at least justifiable) language feature. Save for the
strange worlds of quantum physics, we would expect distinct whole balls to be held in
ballCount—not parts of balls. If the compiler let you assign 3.2 (maybe entered due to a
typo) to ballCount, your program would probably crash later on. To debug your program,
you would then have to track down a tiny but fatal type conversion error (definitely not a
happy coding accident). Additionally, in languages that do permit on-the-fly data type
assignment, it takes more work for the computer to figure out what type of data is held in
a variable.
Because you set the data type of variables when they are declared in Processing and Java,
and that information gets put in the compiled bytecode, the virtual machine (the language
interpreter) needs to do less work. Languages like Processing and Java that work this way
are called statically typed languages. Languages like Python, on the other hand, are
dynamically typed, and, due in part to dynamic typing, run slower than Java and
Processing. Now, at the risk of really getting you rankled, what do you think would happen
if you tried to assign 3 (an integer) to ballSpeed (declared as type float)? Surprisingly,
you wouldn’t get a compiler error. Huh! That seems to go against what I just wrote about
how static typing works. The reason the compiler allows it is because the compiler converts
the 3 to 3.0 automatically. Let’s test this out. If I try running the following code:
float ballSpeed;
ballSpeed = 3;
println(ballSpeed);
I get the following output:
3.0
The reason the compiler lets me get away with this is because there is no danger, nor any
real change, to the value. 3, 3.0, and even 3.0000000000000 are all equal. Not to get too
geeky, but this type of implicit conversion is called a “widening conversion,” where an int
is automatically converted into a float. The rule is that any primitive type will be converted
implicitly (without any help from you) into any other type only if that type supports
a larger value; a float supports a larger value than an int. In regard to Processing, that
would include byte to int and int to float. Bytes can become integers and integers can
become floats. Converting the other way, from a float to an int to a byte (a “narrowing
conversion”) can actually also happen, but you have to do it explicitly (which involves a
little work on your part), with something called type casting, which I’ll cover later in the
book. For now, let’s put this theory stuff to bed and play with variables a little.
Here’s a little program to create a stepped radial gradient (see Figure 3-2). Later on when
I cover loops, I’ll simplify this program, and also show you how to generate a more elegant
continuous gradient. You’ll create the program in three stages. The first stage will fill the
CODE GRAMMAR 101
67
3