Before you can start building applications with Project Builder, you will need to launch the application.

If this is the first time that you have started Project Builder, you will be presented with an Assistant to set up your application preferences.

To create the “Hello, World” project, select File → New Project. Project Builder then displays the New Project Assistant, shown in Figure 2-5, which takes you through a few simple steps to create a new project.

Figure 2-5. Project Builder’s New Project Assistant

The New Project Assistant lets you choose a project type. Based on the type of project you select, your Project will be created with files that serve as a useful starting point. When you select a type of application here, Project Builder creates it for you with a skeleton of the files that you will need for that particular application type. The application types are as follows:

Throughout this book, we focus almost exclusively on two categories of applications: simple tools with no GUI (called Foundation Tools) and applications with GUI windows. For this example, we will build a simple tool that doesn’t have a graphical interface. Proceed as follows:

Figure 2-6. Naming a Project Builder project

When you finish creating the project, the main project window opens, as shown in Figure 2-7.

Figure 2-7. Project Builder’s main window

Notice that Project Builder uses hierarchical groups to organize the various parts of a project. In this project, these groups are the following:

These groups are very flexible in that they do not necessarily reflect either the on-disk layout of the project or the manner in which the build system handles the files. Their sole purpose is to help you organize the files in your project. The default groups created for you by the templates can be used as they are or rearranged however you like.

To see the source code for the application’s entry point as shown in Figure 2-7:

The main.m file contains the entry point for the application. The Foundation Tool project template provides a standard main function that prints “Hello, World!”, so we don’t even need to add any code.

import <Foundation/Foundation.h>                                         // 1

int main (int argc, const char * argv) {                                // 2
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];        // 3

    // insert code here...
    NSLog(@"Hello, World!");                                            // 4
    [pool release];                                                     // 5
    return 0;                                                           // 6
}

Now let’s walk through the code, line-by-line, so you can get a feeling for what’s going on here:

To build the project, click the Build button in the main window. It’s the one that looks like a hammer on the far left side of the toolbar. A dialog box will appear, asking you to “Save before building?” Click Save All, or hit Return, to save and build the project. As the project builds, Project Builder’s build pane opens to reveal detailed information about the build as it progresses. When Project Builder is finished—and encounters no errors along the way—it displays “Build succeeded” in the lower-left corner of the project window, as shown in Figure 2-8.

Figure 2-8. Project Builder after successfully building the project

The code for this program should compile without a problem, since Project Builder generated it. However, when you write code yourself, you won’t always be so lucky. To see how Project Builder notifies you of build problems, let’s create one. Remove the semicolon right after the NSLog(@"Hello, World!") statement; then try building the project. You’ll see a build failure notice, as shown in Figure 2-9.

Figure 2-9. Build failed

Project Builder tells you that there was a syntax and parse error. To see where the error is, click on the syntax error message, and Project Builder highlights the line about which the compiler is complaining. Unfortunately, the compiler is not smart enough to figure out that we don’t have a semicolon in the right place; it just notices that it has run across some syntax that it did not expect. This is typical with syntax errors. If you don’t see the problem at first, look at the line of code above the reported line.

Add the missing semicolon back in after the NSLog function, and recompile by clicking the Build button to get a working program again.

Congratulations! You’ve just created your first Cocoa application and didn’t even have to type in any code. All that is left to do is click the Build and Run button, as shown in Figure 2-10. When the application launches, the Run pane of Project Builder’s main window will enlarge to display the output of the NSLog function.

Figure 2-10. Project Builder’s main window after running Hello World

In addition to the string, the NSLog function prints the current date and time, the program name, and the process ID number (PID) of the program. Since this is a tool application with no GUI, you might want to see the behavior of this program on the command line.

When the program is run, you should see something similar to the following output:

2002-06-08 23:23:29.919 hello[490] Hello, World!

The timestamp and process ID information come in handy when you are looking for the output from a program that was launched from the Finder, but not from inside of Project Builder or from the command line. In those cases, the output from NSLog will show up in the system’s message log. You can easily view these messages using the Console application, also found in the /Applications/Utilities folder.

[localhost:~] duncan% Learning Cocoa/hello/build/hello

To begin constructing a user interface using Interface Builder, the first step is to open the application’s main nib file. Double-click MainMenu.nib in the Resources group of the Groups & Files list of Project Builder’s main window. This will launch Interface Builder (if it is not already running) and open the nib file, as shown in Figure 2-16. A lot of windows will appear. You might want to hide your other running applications so that you can concentrate on just the windows that belong to Interface Builder. You can do this by using the Interface Builder → Hide Others menu.

These are the various parts of Interface Builder (called out in Figure 2-16):

Figure 2-16. Interface Builder

Interface Builder stores all kinds of information about user-interface objects in an application’s nib files. For example, you can set both the size and initial location of an application’s main window by simply resizing and moving the window in Interface Builder.

To create our application, we need to add a text label to the window.

Figure 2-18. Our finished Hello World interface

Next, save your interface, as we are now done with Interface Builder. Some people refer to saving the interface as “freeze-drying” it. All the various parts of the interface—definitions about how they are related and connected—are saved in a form that can be quickly built up at runtime. This process is also called " archiving” or "serialization.”

To see the application in action:

When the application runs, it opens up a window containing the Hello World text. Note that you can resize the window (although the text doesn’t stay centered, we’ll learn how to do that in later chapters), minimize it, maximize it, and close it. You can even quit the application using the menu or the standard

-Qkeyboard shortcut. All of this functionality is simply “built-in” to Cocoa, allowing you to spend more time writing your applications and less time taking care of details you shouldn’t have to.