Every program consists of instructions or code. A simple program might haveonly one line of code, but most programs have hundreds, if not thousands or even millions, of lines of code. To help the compiler understand where each line of code ends, you have to use a semicolon:

NSLog (@"Hello, world!");
NSLog (@"Good-bye!");

The most common mistake programmers make is omitting this all-important semicolon. Omitting the semicolon from the first line, in the previous example, makes the computer think you actually wrote something like this:

NSLog (@"Hello, world!")NSLog (@"Good-bye!");

This line won't work because the computer doesn't know when the first NSLog command that prints "Hello, world!" actually ends. Semicolons may look trivial, but they're extremely important and used whenever you write Objective-C code.

Besides the semicolon, the second most common symbols you'll see are the left and right curly brackets: { and }. Since you'll often need to write multiple lines of code that work together to perform a specific function, curly brackets define the beginning and end of those lines of code:

{
   NSLog (@"Hello, world!")
   NSLog (@"Good-bye!");
}

You always use curly brackets in a method (subprogram) to define all the lines of code stored in that method. When using curly brackets, the ending right curly bracket typically appears on a separate line. However, the beginning left curly bracket can appear at the end of a line:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
    NSLog (@"Hello, world!");
    NSLog (@"Good-bye!");
}

Or the left curly bracket can appear on a separate line:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    NSLog (@"Hello, world!");
    NSLog (@"Good-bye!");
}

To the computer, both approaches are equivalent, so it's more a matter of personal style which method you prefer. You can actually mix both styles in the same program, but it's usually best to stick to one style for consistency.

You may also see nested pairs of curly brackets where one pair of left/right curly brackets appears inside another pair of left/right curly brackets:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    if (response == "true")
    {
       NSLog (@"Hello, world!");
       NSLog (@"Good-bye!");
    }
}

Each left curly bracket must pair up with a matching right curly bracket. By using indentation (which the compiler completely ignores), you can vertically align each matching left/right curly bracket pair. Since the compiler ignores indentation, the Xcode compiler treats the previous code as if it actually looked like this:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
if (response == "true")
{
NSLog (@"Hello, world!");
NSLog (@"Good-bye!");
}
}

Since this code can be harder to read, it's always best to use indentation to make it visually clear where one chunk of code begins and ends. When writing your own Objective-C code, always strive to make it as readable and understandable as possible.

When you run a program, the Xcode compiler examines your code, line by line. However, sometimes you may need to give the compiler special instructions. To do this, you have to put the # symbol in front of these special instructions called compiler directives. The most common compiler directive appears in front of the import keyword:

#import "MyProgramAppDelegate.h"

This #import command tells the Xcode compiler to take any code stored in a specific file (such as the MyProgramAppDelegate.h file) and add or import that code into the current file. From the compiler's point of view, it's as if you crammed all your code from a separate file into the currently displayed file. However, from a programmer's point of view, your program remains divided into different files, which makes editing and modifying these separate files far easier than trying to edit and modify one massive file.

The #import command is one that you'll see and use often since it allows you to access all of Apple's prewritten and tested code without physically copying that code into your own programs.

When writing code, you may need to jot down a note to yourself (or to another programmer) that explains what a particular chunk of code does or what assumptions you've made in writing your code. Rather than jot down these notes on a separate piece of paper (and risk losing or misplacing them), it's easier to write notes directly in your code.

To keep the Xcode compiler from mistaking your notes as code, you need to use special symbols. For identifying a single line as a note or comment, you can use the // characters:

{
   NSLog (@"Hello, world!");
   // This line is a comment

}

Xcode treats anything that appears after the // characters as if it doesn't exist, so the previous code looks like this to the compiler:

{
   NSLog (@"Hello, world!");
}

Comments can appear on a separate line or at the end of a line of code:

{
   NSLog (@"Hello, world!") ;  // This line is also a comment
   // This line is a comment
}

Comments are useful for writing short explanations on how your code works or for identifying the date and name of the last programmer who changed the code. If you need to write comments on multiple lines, you could use the // symbols at the beginning of each line:

{
   NSLog (@"Hello, world!")
   // The line above prints to the log window
   // Last modified on April 1, 2012 by Bob Smith
}

However, typing multiple // symbols in front of each comment can get tedious. For a faster method of turning multiple lines into comments, you can use matching pairs of the slash and asterisk symbols:

{
   NSLog (@"Hello, world!")
   /* These two lines are comments
        Last modified on April 1, 2012 by Bob Smith */
}

The /* and */ symbols tell Xcode that anything in between those matching symbols are a comment that the compiler can ignore. You can use both the // and /* and */ symbols to create comments in your code.

Many times your code will use single-word commands, such as NSLog, to tell the computer to do something. However, one benefit of Objective-C is that you can divide a large program into objects, so instead of just using the built-in commands of Objective-C, you can define your own commands and store them in objects of your own creation.

To identify when you're working with objects in Objective-C, you'll need to use square brackets in a form such as the following:

[object message];

The square brackets identify a single object and the message you're sending to that object. Typically that message sendseither an object data or an instruction:

[textField setStringValue:@"Hello, world!"];
[personalData release];

The first line of code sends the message setStringValue using the data "Hello, world!" to an object called textField. The second line of code sends the message release to an object called personalData. Although you may not understand what these two lines of code actually do at this point, the square brackets identify that you're working with objects.

Just like with pairs of curly brackets, you may also see nested pairs of square brackets:

[[NSObject alloc] init];

Like nested pairs of curly brackets, nested pairs of square brackets must match. For every left square bracket, you need a matching right square bracket. Although square brackets can look unusual, especially if you're used to other programming languages, just remember that square brackets always identify when you're working with objects.

You can use the asterisk symbol in several ways. First, it can represent a multiplication symbol such as 54 * 11. Second, it can identify the beginning and end of a comment:

/* This is a comment */

Third, the asterisk can identify a pointer. When storing data, computers carve out a chunk of memory to hold the data. Each time you need to store more data, your program needs to use more memory.

If you need to store identical data, you could store that data in three separate chunks of memory. However, a more efficient way to use memory is to store that data once and then create pointers to that single copy of data, as shown in Figure 5-3.

Figure 5-3. Pointers let you use memory more efficiently.

In most programming languages, including Objective-C, you can store data in a variable such as assigning 48 to a variable named myAge. When you store data in a variable, that data gets stored in a specific part of the computer's memory, called a memory address. Each time you want to store data, your data gobbles up another chunk of memory.

As an alternative to creating a new chunk of memory, pointers work by referencing or pointing to, a memory address that already stores data. The power of a pointer is that it's much easier and faster to reference or point to a new memory address quickly. The drawback is that if your pointers point to the wrong memory address, your program could physically foul up the computer's memory.

When working with Objective-C and objects, you'll need to use pointers. In Objective-C, a pointer is represented by the asterisk. Since pointers are used with objects and Objective-C programming heavily relies on objects, you'll be using pointers in almost every nontrivial Mac program.

Typically you'll use the asterisk symbol (*) to declare a pointer to an object:

Object *pointer;

Oftentimes you'll see the asterisk symbol (*) used with square brackets:

NSObject *myObject = [[NSObject alloc] init];

Whenever you see asterisks and square brackets, chances are good that the code is working with pointers and objects.

Before you can use a variable, you must create or declare that variable. Declaring a variable simply tells the Xcode compiler that the variable is now available for storing data. There are two parts to declaring a variable.

First, you must define a unique name for your variable. Second, you must define the type of data that the variable can hold.

The name you give a variable is completely arbitrary, although most programmers use a descriptive name. For example, if a variable is meant to hold someone's salary, it's logical to name that variable something like Salary rather than something generic and nondescriptive like X.

Although you can name variables as short as X or as long as Thisisavariablenamethatistoolong, it's common in Mac programming to create variable names that consist of two or more words combined using something called camel case.

With camel case, the first word of the variable appears in lowercase, but the first letter of the second and any additional words appear in uppercase:

variableName
numberHolder
lengthInMeters

After you choose a descriptive name for your variable, the second part in declaring a variable involves defining what type of data it can hold. The most common types of data are numbers, and the two most common types of numbers are integers and floating-point or real numbers.

An integer variable can hold only whole numbers such as 102, 5, or 649. A floating-point variable can holdonly real numbers such as 3.125, 10.24, or 90.08.

To declare an integer variable, you need to use the int keyword followed by the variable name:

int myAge;
int dogsInHouse;
int peopleOnBoard;

To declare a floating-point variable, you need to use the float keyword followed by the variable name:

float stockPrice;
float averageAge;
float medicineQuantity;

Besides declaring variables as int or float data types, a third commonly used data type is the Boolean data type. A Boolean variable can holdonly one of two values, either 1 (YES) or 0 (NO). Boolean data types are often used to help the computer make a decision, and based on the value of a Boolean variable, the computer may follow one set of instructions or another set of instructions.

To declare a Boolean variable, you just need to use the BOOL keyword followed by your variable name:

BOOL doorOpen;
BOOL onTarget;
BOOL windowOpenAndDoorShut;

When you first declare a variable, the value of that variable is unknown. If you try to use a variable right after you declare it, the unknown value of that variable will likely crash your program or make it behave erratically. As soon as you declare a variable, it's a good idea to assign a value to that variable right away.

Assigning a value to a variable simply means using the equal sign (=):

Variable = value;

There are two ways to declare a variable and assign a value to it. The first way involves two separate lines of code:

int myAge;
myAge = 49;

A second way to assign a value to a variable is to combine the variable declaration and the assignment to a value in a single line:

int myAge = 49;

To ensure that a variable never contains an unknown value, it's usually best to use the second method of declaring and assigning a variable in a single line, but as long as you can remember to always assign a value to a variable before using it, you can use whichever method you like.

When you declare a variable, you also declare the scope of that variable. The scope defines which part of your program can access and use that variable. In most cases, you'll declare a variable inside a method so the scope of that variable is visible only to code stored in that same method. For example, suppose you had two methods like this:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    int myCats = 4;
   // More code goes here
}

- (void)countBoxes;
{
    int numberOfBoxes = 75;
   // More code goes here
}

Any code stored in the applicationDidFinishLaunching method could access and use the myCats variable because the myCats variable is declared inside that method. Likewise, any code stored in the countBoxes method could access and use the numberOfBoxes variable because the numberOfBoxes variable is declared inside that method.

The scope of a variable typically lasts from the variable declaration line to the end of the code block where the variable was declared. Since each variable was declared inside the code block that makes up each method, each variable's scope is validonly in that particular subprogram or method.

What happens if you try to access a variable declared in another method like the following?

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    int myCats = 4;
   numberOfBoxes = 120;
}

- (void)countBoxes;
{
    int numberOfBoxes = 75;
   myCats = 1;
}

In both cases, each method is trying to use a variable that was declared in a different method. In the first method, the numberOfBoxes variable is considered undeclared. In the second method, the myCats variable is considered undeclared.

Since the scope of a variable typically extends only within the method where it was declared, it's possible to do the following:

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    int happyPeople = 2;
}

- (void)countBoxes;
{
    int happyPeople = 75;
}

In this example, both methods declare a variable with the same name. Although this may look confusing, it's perfectly valid because the scope of each variable extendsonly to the method that it was declared in. Although this is valid, it's not a good idea to use identical variable names in different parts of your program because the potential for confusion is so high.

As a general rule, any variable you declare will likely be accessible only inside a block of code defined by the curly brackets: { and }.

To get practice declaring and assigning values to variables, this sample program shows how to use the NSLog command to print data stored in two different variables. To create this sample program and see how to declare and use variables, follow these steps:

You may notice that when printing out a floating-point number, the NSLog command printed a bunch of extra zeroes. If you want to define how many numbers you want to appear to the right of the decimal point, you need to specify the number of digits:

NSLog (@"This is my paycheck amount: %.2f", myPaycheck);

This code tells the computer to print the floating-point number with two digits to the right of the decimal point:

2010-08-24 22:39:14.362 VariableTest[1001:a0f] This is my paycheck amount: 5120.75