In the platforms covered in this book, all variables are typed. This means that they have a type that tells the computer what sorts of things are going to be stored in the variable. This is because numbers, letters (usually called characters), and true/false (called boolean values) all require different amounts of space to store and move around.

Here are some of the most common types that you’ll encounter in each of the programming languages in this book.

Signed versus unsigned

As mentioned earlier, variables need to be declared with a type because the computer needs to know how much space they will take up. That means that sometimes an int is 4 bytes or 32 bits of information all the time and that it can store 4 bytes worth of information. So, what happens when you need a negative int? Well, you have to store whether it’s negative or positive, and the way you do that is by moving all the values of the int down into the negative values. For the moment, you’ll see how this works in C++, the language that oF uses, and then the rest of the languages will be addressed. In C++, where the int represents a value in between –2,147,483,647 to 2,147,483,647, if you have an int that is never going to use a negative number, you can use an unsigned int that stores anything from 0 to 4,294,967,295. This is what’s called having signed or unsigned variables. Unsigned variables don’t store negative numbers, whereas signed variables do. The way this works requires a little bit of thinking about binary numbers.

An int is 32 binary values. Binary counting uses 1 and 0 to count instead of 0 through 9 like we’re used to doing. This means that when you want to set a variable to 1, you’ll actually be storing the value 1 in the place where the variable is stored. When you want to store the value 2, you’ll be storing 10, which means 1 in the 2’s place and nothing in the 1’s place. Additionally, 3 is represented as 11, which means 1 in the 2’s place and 1 in the 1’s place, for 2+1, which is 3. Further, 4 is represented as 100, which is 1 in the 4’s place and nothing in the 2’s or 1’s place. Therefore, 16 is 1,000, 17 is 1,001, 18 is 1,010, and so on. This is called two’s complement math because it counts everything up by squaring for the next value. That’s a very quick introduction to binary math, but don’t worry, there’s a much more comprehensive discussion of this in several chapters later in this book where you begin using bits and binary.

Figure 2-1 shows the ways that signed and unsigned variables work. Remember that in C++ the int is 32 bits, so there will be 32 boxes to show what each bit stores.

Figure 2-1. Setting the bits of signed and unsigned variables

In unsigned numbers, the first bit is counted like any other bit. In signed numbers, the first bit is used to store whether the number is positive or not, and this is why unsigned variables can store larger values than signed variables.

Arduino and C++ use unsigned variables, and all variables are signed unless you indicate otherwise by putting unsigned in front of the variable type:

unsigned int = 5;

Processing does not use unsigned variables; all numerical variables in Processing are signed.

In C++, the language you’ll use with oF, signed ints are −2,147,483,647 to 2,147,483,647, and unsigned ints are between 0 and 4,294,967,295. In Arduino, the int can be between −32,768 to 32,767. Tricky? Not really. Lots of times you won’t have to think about what you’re storing in the int. When you do have to think about how large the value you’re going to be storing is, it’s time to use a bigger number type, like long or double. We’ll discuss these later in this section. When using Processing, you never have to think about how large the value will be at all, so it isn’t a problem. Simply figure out whether you’ll need a decimal point. If you do, then use a float; if you don’t, then use an int.

char firstLetter = 'a';
char secondLetter = 'b';

char thirdLetter = 'a' + 'b'; // this won't become 'ab' or 'c'

char a = 'a';
char b = 'b';
int  c = a+b; // notice that a+b is being stored as an int

boolean b = true;

bool  b = true;

boolean true = false;

String f = "foo";
String b = "bar";
String fb = f+b;// this will be "foobar"

string f = "foo";
string b = "bar";
string foobar = f+" "+b;// this will be "foo bar" note the space w/in quotes

String super = "super";

String quoted = "He said "It's super"."

String quoted = "\that's great!";

"    hat's great!"

byte firstByte = 55;
byte newByte = 10+firstByte;

The array is a slightly more complex datatype than the ones that were shown earlier. An array contains one or more variables in a list. Remember one of the problems that you’re going to run into in this book is that there are three different programming platforms used in this book, each of which does things slightly differently. We’ll look at three different arrays filled with integers in each of our platforms to give you a feel for the similarities and differences.

The array is a list of multiple elements; in the code snippet below, it will contain integers. You’re going to create an array that holds three int values: 1, 2, 3. It’s nothing too thrilling, but it’s a good place to start.

Note the markers above each of the elements in the array in Figure 2-2: numbers[0], numbers[1], numbers[2]. These are the array access operators. That’s not a typo; they do count up from 0. We’ll come back to these after we look at creating the array.

Figure 2-2. An array with three integers

Here’s what the array looks like in Processing:

int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;

First, look at the declaration of the array, as shown in Figure 2-3.

Figure 2-3. An array containing three integers as declared in Processing

You can declare arrays to be filled with any type, even types that you create yourself. We’ll get to this later. The code snippet sets all the values of the array. When you want to access an element in the array, you use the access operators, [] to access the index position in the array that is specified within the square brackets:

int x = numbers[0];

The previous sets x to 1, because the first item in our numbers array is 1:

int y = numbers[1] + numbers[2];

The previous sets y to the values of the second plus the third elements of numbers, that is, 2 plus 3, which equals 5. If you use the = operator in front of the array with the access operator, it sets the value of the element in the array at that point:

numbers[0] = 1;
numbers[0] = 5;

Whereas numbers[0] originally was 1, it is now 5. The array is really storage, and each element in the array is like a box that can store any variable of the type declared when the array is created. When any item within the array is set, it will store that value until it is changed.

Instead of putting each number into the array on a separate line of code, the array values can be created all at once:

int arr[] = {1, 2, 3};

or:

int arr[3] = {1, 2, 3};

Note that above the array does not need to have a number length assigned to it. This results in the same array as creating the array in the first example; however, it assumes that you know all the values that will go into the array. If you do not, use the first method described.

The next language to look at is the declaration of an array in Arduino. Luckily for the sake of brevity, the Arduino platform deals with arrays very similarly to Processing. Creating an array in Arduino or C++ can be done in any one of the three following ways.

Here’s what the array looks like in Arduino or C++:

int arr[] = {1, 2, 3};

or:

int arr[3];

or:

int array[3] = {1, 2, 3};

Figure 2-4 breaks down the parts in the array.

Figure 2-4. Creating an array in C++

The only difference between the array in Processing and in Arduino is that while Processing supports the new keyword when creating an array, Arduino does not. If you know all the elements when you’re creating the array, do it like so:

int array[3] = {1, 2, 3};

Otherwise, you should construct an array like this:

int[] arr = new int[3];

Now that we’ve covered the basics of arrays, you’ll look at some of the more complex aspects of dealing with the array. The first is the error that you’re sure to encounter at some point, specifically, the “out of bounds access” error in all its many forms. What this means is that you’ve tried to access an element in the array that does not exist.

In Arduino and C++, arrays can be initialized as shown here:

char arr[3] = {'a', 'b', 'c'};
char badArrayAccess = arr[3];

When you try to do something with the badArrayAccess variable, you’ll find that not only is it not a char, but that accessing it might just crash your program. This is because the array arr contains three char variables, and you’re trying to access a fourth one, which violates the number of elements established when declaring the array. Another mistake is trying to store the wrong kinds of variables in the array, as shown here:

char arr[3]; // an array of chars, with space for 3 variables
float f = 2.3;
arr[0] = f; // oops! arr expects chars, so will turn f into "2"
bool b = true;
arr[1] = b; // oops! arr expects chars, so will convert b into "1"

This won’t cause an error; however, it won’t return the variables correctly, because the array declared is expecting char variables, so when you place float and bool variables within that array, it automatically converts them to char, with frequently unpredictable results. Table 2-1 is a quick comparison of the datatypes and how the three languages use them.

What do you do if you have a number that is an integer but you need it to be a float? You cast it. This means that you convert it from its original type into a new type:

Here’s what casting looks like in Processing, Arduino, and C++:

int i = 5;
float f = (float)i; // float is now 5.0

Why can’t you simply set f to i?

float f = i;

Types won’t allow you to do that, because that’s the point of a type. You know what specific type values are, how much memory they require, and how they can be used. The previous code will cause an error if you try to run it. Instead, cast the variable. You can’t change the type of a variable once it’s declared. In this example, i will always be an int, but if you need to use it as a float, you can very easily cast it. Some other examples of casting involving char variables because they are such a fundamental datatype. For instance, if you want to cast a char to a float and then back you do the following:

char ch = 'f';
int fAsInt = (int)ch;// now fAsInt is 102
char newChar = char(fAsInt); // newChar is now 'f'

One important thing to note is that you cannot cast an array:

char[] foo = {'a', 'b', 'c', 'd'};
int[](foo); // ERROR

To cast anything in an array, you need to cast every element of the array. We’ll cover this in greater detail in the sections on loops, but for now, we’ll look at this:

char[] foo = {'a', 'b', 'c', 'd'};
int i = int(foo[0]);

Here you create an array of char variables and then read one of those char values out of the array and cast it as an int.

Operators are the symbols that a compiler uses to perform commands and calculations in your program. Operators let you set variables like the = operator, compare variables like the == operator, add variables like the + operator, and so on. There are three major types of operators. The first operators are the mathematical operators that perform mathematical operations. These should be familiar from any math class you’ve ever taken. The second are assignment operators that change values. The third are comparison operators, which determine whether two variables are equal, different, greater than, or less than another variable.

Mathematical operators work pretty much as expected, with one notable exception. + adds two values, for example:

int apples = 5
int moreApples = apples + 3; // moreApples is equal to 8.

The exception occurs when you add strings; you end up with the two strings stuck together:

string first = "John";
string second = "Brown";
string full = first+second; // now full is JohnBrown

This is because of something called operator overloading. If you’re curious enough, you can check some of the recommended programming books from Chapter 18 for a full description, or look online because it’s a more advanced topic.

The other simple mathematical operators are – (subtraction), * (multiplication), and / (division). The last mathematical operator is %, the modulo.

The modulo tells you what is left over (the remainder) when the value on the left is divided by the value on the right. Here are some examples:

8 % 2 // equals 0 since there's no remainder when 8 is divided by 2
17 % 2 // equals 1 since there's a remainder of 1 when 17 is divided by 2
19 % 5 // equals 4 since the remainder is 4 when 19 is divided by 5
12 % 11 // equals 1 since the a remainder of 1 when 12 is divided by 11
19.0 % 5 // equals 4.0 since we're dealing with floats

Assignment operators work from right to left. That is, the operator uses the value on the right to assign or change the variable on the left. For example:

int age = 6;

The = operator sets the variable on the left to 6. There are other types of assignment operators that change the value of the variable on the left, just like the = operator. For instance:

Comparisons are very important in programming and particularly important in using control statements, which will be discussed in the next section. Before we get to that, though, you need to become familiar with the various operators. These operators are common across all the programming languages discussed in this book and, with slight variations, across all programming languages. Comparisons allow you to determine whether variables are the same, different, greater than, or less than one another:

You may be wondering what to do with all these evaluations and comparisons. The answer is control statements. Table 2-2 lists operators and their uses.

The if/then is a conditional logic statement, and it works just like it does in English: “If it’s raining, then I’ll bring an umbrella.” These statements look like this:

if(condition) {
    result if the condition is true
} else {
    result if the condition is false
}

There must be a true/false expression in the brackets next to the if. Here’s an example:

int myWeight = 72;

if(myWeight > 100) {
    print(" you're getting heavy! ");
} else {
    print(" you're still doing ok ");
}

You can also use the if statement without an else:

int myHeight = 181;

if(myHeight > 200) {
    print(" you're too tall ");
}

This just means that the actions inside the brackets will execute if the statement is true; otherwise, you don’t do anything. You can also check that things are not true:

boolean allDone = false;

if(!allDone) {  // if not all done
    print(" keep going! ");
} else {
    print(" ok, quit! ");
}

There is one last permutation on this pattern:

if(age == 5){
    print(" you're 5!");
} else if(age == 25) {
    print(" you're 25!");
} else {
    print(" can't login "); // if neither of the above is true
}

In this example, there is a new term introduced, else if. What this does is evaluate another statement before going on to the else statement. This means that if the first statement doesn’t evaluate to true, then check each else if looking for the first one that is true. If none is true, then do the else statement.

The for statement lets us do things over and over again, for a specified number of repetitions. Loops are frequently used to loop through arrays and examine, use, or alter each element within them. This is going to be particularly useful when dealing with the pixels in images or frames of video, as well as sounds, data from the Internet, and many other kinds of information that needs to be sorted through:

int i;
for(i = 0; i < 10; i++) {
    print(char(i)+", "); // this will print 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
}

The for statement uses three different statements, as shown in Figure 2-5.

Figure 2-5. A for loop

The integer i is used to set the number of times that the loop will execute, running all the code inside the code block. In the initialization of the for loop, you set i to 0; as long as i is less than 10, you continue looping, and each time the for loop is passed, i is incremented by 1.

Of course, it is also entirely possible to use subtraction in the for loop:

for(int i = 5; i>-1; i--){
   print(i);
}

Another great use of the for loop is to go through an array and look at each item in the array:

int[] intArr = {0, 1, 2, 3, 4, 5};
int sum = 0;
for(int j = 0; j < 6; j++){
    sum += intArr[j]; // we'll get the item in the array using the loop
}

Each time the loop executes, sum will be incremented using the next integer in the intArr array.

The while loop is similar to the for loop, but it is slightly less sophisticated:

while(trueOrFalse){
//something to do each time
}

As long as the expression that the while is evaluating each time through remains true, the loop will continue executing. This is important to note because if the evaluated variable does not become false, the loop will never exit, and your program could become locked up while the loop runs. Creating an infinite loop—that is, a loop that never exits—is easy and will certainly make your program unusable, so take care when using any of the control statements. Here’s an example using a counter, much like in the for loop:

int j = 0;

while(j < 100) {
    print(" what's up? "+j);
    j++; // if j is not incremented we end up with an infinite loop
}

Each time the loop executes, the integer j is incremented. When j is no longer less than 100, the loop is exited, and the program continues on:

boolean ready = false;
float number = 0.0;

while(ready != true) {
    print(" we're just waiting" );
    number += 0.1;
    if(number > 1.0){
        ready = true;
    }
}
print(" we're ready ");

In this example, you increment a number and use a second variable, a Boolean value, to determine whether you are in fact ready. Until the ready variable is true, the loop will continue executing, and the “we’re ready” message will not be printed.

The continue statement tells a loop to skip over any further instructions and go on to the next repetition. For instance, if you wanted to loop through a certain number of items and process only odd numbers, you could do this:

for(int i = 0; i< 10; i++) {
    if( i % 2 == 0){
        continue;
    }
    println(i + " is not divisible by 2");
}

This will print the following:

1 is not divisible by 2
3 is not divisible by 2
5 is not divisible by 2
7 is not divisible by 2
9 is not divisible by 2

The continue statement here starts the loop over again. If you have a complicated operation to perform, then using the continue statement allows you to evaluate whether you need to run that operation and to skip it if you do not. This means your code does only what is necessary.

The break statement breaks the loop. It is a great tool to use when you’re looping through an array looking for something and suddenly you find it. Once you’ve found it, you can quit looping easily by using the break statement:

int[] intArr = {1, 2, 3, 4, 5, 6, 2, 12, 2, 1, 19, 123, 1, 3, 13};
int counter = 0;

while(counter < intArr.length)
{
    if(intArr[counter] == 5) { // we're looking for 5
        print(" found it at ");
        break;
    }
    counter++;
}
// code will continue from here after the break
print(counter); // found the value 5 in intArr[4]

To turn the written example into code, you would define a variable to be used to keep track of all the money that you have:

int myBank = 0;

Then you create a function that takes money, adds it to myBank, and returns that value:

int moneyReceived(int money){
  myBank += money;
  return myBank;
}

Now, you have defined a function called moneyReceived(). Using pseudocode or talking though what a function is supposed to do can be quite helpful when trying to understand it. “Take an integer, add it to the money already in the bank, and return that value.” Figure 2-6 is a diagram that helps walk you through what the function is supposed to do.

Figure 2-6. Declaring a function

Notice that the return statement is returning something that is of the same type as the type listed in front of the function name. The variable myBank is an int that the moneyReceived() function returns.

Once the function is defined, it’s time to call it. To call the function, you need to pass the correct kinds of parameters to it, which requires knowing what parameters the function requires. In the moneyReceived() function example, the required parameter is a single integer. Both of the following examples are legal:

moneyReceived(4);

or:

int priceOfDinner = 17;
moneyReceived(priceOfDinner);

This next one is not legal:

float f = 1.32;
moneyReceived(f);

because the variable being passed to the function is not the correct type. This is why being able to see the function declaration, that is, where its return type, name, and parameters are established, is so important.

The return statement indicates the type of value that the method will return, just as a type for a variable determines what kind of value the variable will store. Functions that don’t return anything are declared void, and any other kind of return value needs to be declared. For example, if you created a function that would return a char, you would declare it like so:

char myFunction()

Note that the function always has the following pattern: type, function name, parentheses, and any parameters that need to be passed to the function:

int multiplyByTwo(int value){
    return value * 2;
}

This previous function takes an integer value, multiplies that value by 2, and then returns whatever that value is. When a function has a return type, it can be used to set the values of variables:

int x = 5;
int twoTimesX = multiplyByTwo(x); // twoTimesX is now 10

Here, you use a function to return a char based on the value passed into the function:

char convertIntToChar(int i){
    char ch = char(i);
    return ch;
}

New variables can be set using the values returned from a function:

string addExclamationPoints(string s) {
    return s+"!!!";
}
string myStr = addExclamationPoints("hello"); // myStr will be 'hello!!!'

That’s a bit tricky to see what’s going on at first, but you simply have to understand that the function is going to become equal to a string when it’s all done with its operations, which means that you can treat it like a string. Your program will take care of making sure that everything within the function will be run before it gets used to set the value of the variable.

That’s why having functions typed is so important. Anything typed as an integer can be used to create a new integer:

int squareOfEight = square(8);

This will work if the square() function looks like this:

int square(int val) {
    return val*val;
}

Since square() returns an int, you can use it set an int. If it returned a float or another datatype, it wouldn’t work, which makes reading and understanding the return types of functions so important.

Name them well. Functions should do what their names indicate. A function called square is very well named if it takes an integer or float as a parameter and returns the square of that value. It’s not so well named if it doesn’t do that. Generally thinking of functions as verbs is a good way to go because it makes you think about what that thing should do in the first place and help you remember what you meant it to do later when you have to look back at it.

Make them no smaller than sensible and no larger than necessary. A function of 200 to 300 lines of code should probably be broken down into smaller functions. This helps you reuse different parts of the code in different places, where necessary, and helps you locate problems more quickly when they occur. Being able to isolate a problem to several lines of code instead of several hundred can save you hours.

When you find yourself needing to do the same tasks repeatedly, put the code into a function and call that function. For instance, if you are frequently resizing images and saving them to a folder somewhere online, you could make a function like this:

resizeAndSave(int picHeight, int picWidth, String urlToSave)

This cleans up your code, saves you typing, and makes debugging problems easier. The less stuff you have to look at, the more quickly you’ll be able to find things, locate problems, and remember where you left off in a piece of code.

Function declarations are important for two reasons. First, the function declaration tells you what parameters to pass to the function and what kinds of things you can do with any values returned from a function. Second, the function declaration and the parameters that the function take are unique for the function that the compiler uses. A function that accepts two strings is considered different from a function that accepts three strings, even if those functions have the same name. Making multiple functions with the same name that accept different parameters allows you to use the same functionality to handle different situations. This is called overloading a method, allowing it to accept multiple sets of parameters.

Think of a verb like “draw.” It’s easy for us to differentiate between “drawing a picture” and “drawing a card” because of the context. The compiler treats functions that same way, which makes it easier for us to name functions with the same functionality by the same name and rely on the compiler to differentiate between them using the context of the kinds of parameters passed. Sizes for a video could be set using int values or float values, for example. The compiler considers each of these functions to be completely separate, even if they have the same name. When the function is called, if float values are passed, then the function of that name that accepts floats is used.

Here is an example of an overloaded function in Processing:

char multiplyByTwo(char value){

    return char(int(value) * 2);
}

String multiplyByTwo(String value) {
    return value+value;
}

int multiplyByTwo(int value){

    return value * 2;
}

int[] multiplyByTwo(int value[]){
    for(int i = 0; i<value.length; i++) {
        value[i] *= 2;
    }
    return value;
}

This function accepts an int, a String, a char, and an array of ints (int[]). The version of the function that will be called is dependent on what is passed to it.

Here it is in Processing:

    println(multiplyByTwo('z'));// this will print ô
    println(multiplyByTwo(5)); // this will print 10
    println(multiplyByTwo("string"));// this will print stringstring
    int[] foo = {1, 2, 3, 4};
    println(multiplyByTwo(foo));//this will print 2, 4, 6, 8

Overloading functions is a great tool because it allows you to make a single way to do something and modify it slightly to take different kinds of variables as parameters. One thing to note is that although having different types of parameters, as shown here, is fine:

int function(int i) {
}

int function(float f) {
}

int function(char c) {
}

having different return types does not always work:

int function(int i) {
}

float function(float f) {
}

char function(char c) {
}

This will throw an error in Arduino and C++ but not in Processing. Generally, it’s not the best idea, but it’s your code, your project, and your call.