sams teach yourself core data for mac and ios in 24 hours 2nd (2012)

ptg8126863
ptg8126863
800 East 96th Street, Indianapolis, Indiana, 46240 USA
Jesse Feiler
Sams Teach Yourself
24
in
Hours
Core Data for
Mac
®
and iOS
Second Edition
ptg8126863
Sams Teach Yourself Core Data for Mac® and iOS in 24 Hours,
Second Edition
Copyright © 2012 by Pearson Education, Inc.
All rights reserved. No part of this book shall be reproduced, stored in a retrieval system, or
transmitted by any means, electronic, mechanical, photocopying, recording, or otherwise, without
written permission from the publisher. No patent liability is assumed with respect to the use of
the information contained herein. Although every precaution has been taken in the preparation of
this book, the publisher and author assume no responsibility for errors or omissions. Nor is any
liability assumed for damages resulting from the use of the information contained herein.
ISBN-13: 978-0-672-33619-5
ISBN-10: 0-672-33619-7
Library of Congress Cataloging-in-Publication data is on file.
Printed in the United States of America
First Printing: June 2012
Trademarks
All terms mentioned in this book that are known to be trademarks or service marks have been
appropriately capitalized. Sams Publishing cannot attest to the accuracy of this information.

Use of a term in this book should not be regarded as affecting the validity of any trademark or
service mark.
Warning and Disclaimer
Every effort has been made to make this book as complete and as accurate as possible, but no
warranty or fitness is implied. The information provided is on an “as is” basis. The author and the
publisher shall have neither liability nor responsibility to any person or entity with respect to any
loss or damages arising from the information contained in this book.
Bulk Sales
Sams Publishing offers excellent discounts on this book when ordered in quantity for bulk
purchases or special sales. For more information, please contact
U.S. Corporate and Government Sales
1-800-382-3419

For sales outside of the U.S., please contact
International Sales

Editor-in-Chief
Greg Wiegand
Executive Editor
Loretta Yates
Development
Editor
Sondra Scott
Managing Editor
Sandra Schroeder
Project Editor
Mandie Frank
Indexer
Brad Herriman
Proofreader

Megan Wade
Technical Editor
Robert McGovern
Publishing
Coordinator
Cindy Teeters
Designer
Gary Adair
Compositor
Mark Shirar
ptg8126863
Contents at a Glance
Introduction 1
Part I: Getting Started with Core Data
HOUR 1: Introducing Xcode 4 7
2: Creating a Simple App 49
3: Understanding the Basic Code Structure 63
Part II: Using Core Data
HOUR 4: Getting the Big Core Data Picture 85
5: Working with Data Models 101
6: Working with the Core Data Model Editor 117
7: What Managed Objects Can Do 133
8: Controllers: Integrating the Data Model with Your Code 143
9: Fetching Data 153
10: Working with Predicates and Sorting 171
Part III: Developing the Core Data Interface
HOUR 11: Finding Your Way Around the Interface Builder Editor:
The Graphics Story 189
12: Finding Your Way Around the Interface Builder Editor:
The Code Story

209
13: Control-Dragging Your Way to Code 223
14: Working with Storyboards and Swapping Views 239
Part IV: Building the Core Data Code
HOUR 15: Saving Data with a Navigation Interface 257
16: Using Split Views on iPad 279
17: Structuring Apps for Core Data, Documents,
and Shoeboxes
289
18: Validating Data 317
iii
ptg8126863
iv
Part V: Managing Data and Interfaces
HOUR 19: Using UITableView on iOS 337
20: Using NSTableView on Mac OS 363
21: Rearranging Table Rows on iOS 375
22: Managing Validation 393
23: Interacting with Users 409
24: Migrating Data Models 423
Appendix
A What’s Old in Core Data, Cocoa, Xcode, and Objective-C 441
Index 443
ptg8126863
Table of Contents
Introduction 1
Who Should Read This Book 1
Some Points to Keep in Mind 2
How This Book Is Organized 3
Part I: Getting Started with Core Data

HOUR 1: Introducing Xcode 4 7
Getting to Know Xcode 8
Goodbye “Hello, World” 8
Hello, App Development for Mac OS X and iOS 11
Getting Started with Xcode 13
Using the Navigator 15
Using Editors 25
Working with Assistant 29
Getting Help in an Editor Window 31
Using Utilities—Inspectors 31
Using Utilities—Libraries 35
Using the Text Editor 40
Using the Organizer Window 45
Summary 47
Workshop 48
Activities 48
HOUR 2: Creating a Simple App
49
Starting to Build an App 49
Building the Project 52
Exploring the App 58
Summary 60
Workshop 60
Activities 61
v
ptg8126863
vi
HOUR 3: Understanding the Basic Code Structure
63
Working with the Code 63

Looking at Object-Oriented Programming in the Context
of Objective-C 66
Using Declared Properties 68
Messaging in Objective-C 73
Using Protocols and Delegates 75
Using the Model/View/Controller Concepts 81
Importing and Using Declarations in Files 82
Summary 83
Workshop 84
Activities 84
Part II: Using Core Data
HOUR 4: Getting the Big Core Data Picture 85
Starting Out with Core Data 85
Examining Core Data at Runtime: The Core Data Stack 90
Working with Fetched Results 96
Summary 99
Workshop 99
Activities 99
HOUR 5: Working with Data Models
101
Making the Abstract Concrete 101
Working with Entities 103
Adding Attributes to Entities 105
Linking Entities with Relationships 107
Keeping Track of Your Data in Files and Documents 108
Summary 116
Workshop 116
Activities 116
Sams Teach Yourself Core Data for Mac and iOS in 24 Hours, Second Edition
ptg8126863

HOUR 6: Working with the Core Data Model Editor 117
Moving the Data Model from Paper to Xcode and
the Core Data Model Editor 117
Adding Entities to the Data Model 119
Choosing the Editor Style 125
Adding Relationships to a Data Model 126
Summary 132
Workshop 132
Activities 132
HOUR 7: What Managed Objects Can Do
133
Using Managed Objects 133
Deciding Whether to Override NSManagedObject 134
Overriding NSManagedObject 136
Implementing Transformation in an NSManagedObject Subclass 140
Summary 142
Workshop 142
Activities 142
HOUR 8: Controllers: Integrating the Data Model with Your Code
143
Looking Inside Model/View/Controller 143
Integrating Views and Data on Mac OS 147
Integrating Views and Data on iOS 151
Summary 152
Workshop 152
Activities 152
HOUR 9: Fetching Data
153
Choosing the Core Data Architecture 153
Exploring the Core Data Fetching Process 154

Using Managed Object Contexts 158
Creating and Using a Fetch Request 159
Stopping the Action to Add New Data 161
Optimizing Interfaces for Core Data 162
vii
Contents
ptg8126863
viii
Summary 168
Workshop 168
Activities 169
HOUR 10: Working with Predicates and Sorting
171
Understanding Predicates 171
Constructing Predicates 177
Creating a Fetch Request and Predicate with Xcode 178
Sorting Data 185
Summary 187
Workshop 187
Activities 187
Part III: Developing the Core Data Interface
HOUR 11: Finding Your Way Around the Interface Builder Editor:
The Graphics Story 189
Starting to Work with the Interface Builder Editor in Xcode 189
Working with the Canvas 197
Summary 206
Workshop 206
Activities 207
HOUR 12: Finding Your Way Around the Interface Builder Editor:
The Code Story 209

Using the Connections Inspector 209
Using IBOutlets for Data Elements 215
Summary 222
Workshop 222
Activities 222
HOUR 13: Control-Dragging Your Way to Code
223
Repurposing the Master-Detail Application Template 223
Adding New Fields as IBOutlets 230
Summary 237
Sams Teach Yourself Core Data for Mac and iOS in 24 Hours, Second Edition
ptg8126863
Workshop 237
Activities 238
HOUR 14: Working with Storyboards and Swapping Views
239
Creating a Project with a Storyboard 239
Swapping Views on iOS Devices 241
Swapping Detail Views (the Old Way) 244
Understanding the Storyboard Concept 246
Looking at the Estimator Storyboard and Code 248
Creating a Storyboard 251
Summary 254
Workshop 255
Activities 255
Part IV: Building the Core Data Code
HOUR 15: Saving Data with a Navigation Interface 257
Using a Navigation Interface to Edit and Save Data 257
Starting from the Master-Detail Template 263
Using the Debugger to Watch the Action 267

Adding a Managed Object 272
Moving and Saving Data 273
Cleaning Up the Interface 275
Summary 277
Workshop 278
Activities 278
HOUR 16: Using Split Views on iPad
279
Moving to the iPad 279
Implementing the Second Interface 281
Changing the Data Update and Saving Code 284
Summary 287
Workshop 287
Activities 288
ix
Contents
ptg8126863
x
HOUR 17: Structuring Apps for Core Data, Documents, and Shoeboxes
289
Looking at Apps from the Core Data Point of View:
The Role of Documents 289
Exploring App Structure for Documents, Mac OS, and iOS 292
Moving Data Models 311
Moving a Data Model from One Project to Another 312
Summary 315
Workshop 316
Activities 316
HOUR 18: Validating Data
317

Using Validation Rules in the Data Model 317
Setting Up Rules in Your Data Model 320
Entering Data into the Interface and Moving It to the Data Model
(and Vice Versa) 327
Creating Subclasses of NSManagedObject for Your Entities 331
Summary 335
Workshop 336
Activities 336
Part V: Managing Data and Interfaces
HOUR 19: Using UITableView on iOS 337
Working with Table Views and iOS, Mac OS, and Core Data 337
Comparing Interfaces: Settings on iOS and System Preferences
on Mac OS 339
Using UITableView Without Core Data 344
Using UITableView with Core Data 357
Summary 360
Workshop 361
Activities 361
HOUR 20: Using NSTableView on Mac OS
363
Exploring the New NSTableView Features 363
Building an NSTableView App 366
Sams Teach Yourself Core Data for Mac and iOS in 24 Hours, Second Edition
ptg8126863
Summary 373
Workshop 374
Activities 374
HOUR 21: Rearranging Table Rows on iOS
375
Handling the Ordering of Table Rows 375

Allowing a Table Row to Be Moved 380
Doing the Move 382
Summary 391
Workshop 392
Activities 392
HOUR 22: Managing Validation
393
Validation for Free 393
Validation on Mac OS 394
Programming Validation for iOS or Mac OS 402
Summary 407
Workshop 407
Activities 408
HOUR 23: Interacting with Users
409
Choosing an Editing Interface 409
Communicating with Users 413
Using Sheets and Modal Windows on Mac OS 419
Summary 422
Workshop 422
Activities 422
HOUR 24: Migrating Data Models
423
Introducing the Core Data Migration Continuum 423
Managing Data Model Migration 424
Working with Data Model Versions 426
Using Automatic Lightweight Migration 432
Looking at a Mapping Model Overview 434
xi
Contents

ptg8126863
xii
Summary 438
Workshop 438
Activities 439
APPENDIX A: What’s Old in Core Data, Cocoa, Xcode, and Objective-C
441
Declared Properties 441
Required and Optional Methods in Protocols 442
Storyboards in Interface Builder 442
Ordered Relationships 442
Index 443
Sams Teach Yourself Core Data for Mac and iOS in 24 Hours, Second Edition
ptg8126863
About the Author
Jesse Feiler is a developer, web designer, trainer, and author. He has been an Apple devel-
oper since 1985 and has worked with mobile devices starting with Apple’s Newton and con-
tinuing with the iOS products such as the iPhone, iPod touch, and iPad. Feiler’s database
expertise includes mainframe databases such as DMS II (on Burroughs), DB2 (on IBM), and
Oracle (on various platforms), as well as personal computer databases from dBase to the
first versions of FileMaker. His database clients have included Federal Reserve Bank of New
York; Young & Rubicam (advertising); and many small and nonprofit organizations, pri-
marily in publishing, production, and management.
Feiler’s books include the following:
.
Sams Teach Yourself Objective-C in 24 Hours (Sams/Pearson)
.
Data-Driven iOS Apps for iPad and iPhone with FileMaker Pro, Bento by FileMaker, and
FileMaker Go (Sams/Pearson)
.

FileMaker 12 in Depth (Sams/Pearson)
.
Using FileMaker Bento (Sams/Pearson)
.
iWork for Dummies (Wiley)
.
Sams Teach Yourself Drupal in 24 Hours (Sams/Pearson)
.
Get Rich with Apps! Your Guide to Reaching More Customers and Making Money NOW
(McGraw-Hill)
.
Database-Driven Web Sites (Harcourt)
.
How to Do Everything with Web 2.0 Mashups (McGraw-Hill)
.
The Bento Book (Sams/Pearson)
He is the author of MinutesMachine, the meeting management software for iPad—get more
details at champlainarts.com.
A native of Washington, D.C., Feiler has lived in New York City and currently lives in
Plattsburgh, NY. He can be reached at northcountryconsulting.com.
xiii
ptg8126863
xiv
Acknowledgments
Thanks go most of all to the people at Apple, along with the developers and users who have
helped to build the platform and imagine possibilities together to make the world better.
At Pearson, Loretta Yates, Executive Editor, has taken a concept and moved it from an idea
through the adventures along the way to printed books and eBooks in a variety of formats.
She is always a pleasure to work with.
Mandie Frank, Project Editor, has done a terrific job of keeping things on track with a

complex book full of code snippets, figures, and cross references in addition to the text.
Technical Editor Robert McGovern caught numerous technical typos and added comments
and perspectives that have clarified and enhanced the book.
As always, Carole Jelen at Waterside Productions has provided help and guidance in bring-
ing this book to fruition.
ptg8126863
We Want to Hear from You!
As the reader of this book, you are our most important critic and commentator. We value
your opinion and want to know what we’re doing right, what we could do better, what
areas you’d like to see us publish in, and any other words of wisdom you’re willing to pass
our way.
As an Editor-in-Chief for Sams Publishing, I welcome your comments. You can email or
write me directly to let me know what you did or didn’t like about this book—as well as
what we can do to make our books better.
Please note that I cannot help you with technical problems related to the topic of this book. We do
have a User Services group, however, where I will forward specific technical questions related to the
book.
When you write, please be sure to include this book’s title and author as well as your name,
email address, and phone number. I will carefully review your comments and share them
with the author and editors who worked on the book.
Email:
Mail: Greg Wiegand
Editor-in-Chief
Sams Publishing
800 East 96th Street
Indianapolis, IN 46240 USA
Reader Services
Visit our website and register this book at amspublishing.com/register for convenient access
to any updates, downloads, or errata that might be available for this book.
xv

ptg8126863
This page intentionally left blank
ptg8126863
Who Should Read This Book
1
Introduction
Organizing things is an important human activity. Whether it is a child organizing
toys in some way (by size, color, favorites, and so forth) or an adult piecing together
a thousand-piece jigsaw puzzle, the desire to “make order out of chaos” (as one
inveterate puzzler put it) reflects a sense that somehow if we try hard enough or just
have enough information, we can find or create an understandable view of the
world. Or at least an understandable view of the left overs in the refrigerator or the
photos in an album.
Core Data is a powerful tool that you can use with the Cocoa and Cocoa Touch
frameworks on iOS and Mac OS to help you make order out of the chaos of the hun-
dreds, thousands, and even billions of data elements that you now can store on your
computer or mobile device.
Who Should Read This Book
This book is geared toward developers who need to understand Core Data and its
capabilities. It’s also aimed at developers who aren’t certain they need the combina-
tion of Core Data and Cocoa. It places the technologies in perspective so that you
can see where you and your project fit in. Part of that is simply analytical, but for
everyone, the hands-on examples provide background as well as the beginnings of
applications (apps) that you can create with these two technologies.
If you are new to databases or SQL, you will find a basic introduction here. If you
are familiar with them, you will find a refresher as well as details on how the con-
cepts you know already map to Core Data terminology.
Likewise, if you are new to development on Mac OS, iOS, or Cocoa and Cocoa
Touch, you will find a fairly detailed introduction. If you are already familiar with
them, you will see how some of the basic concepts have been expanded and

rearranged to work with Core Data.
There is a theme that recurs in this book: links and connections between interface
and code as well the connections between your app and the database. Much of what
you find in this book helps you develop the separate components (interface, data-
base, and code) and find simple ways to link them.
ptg8126863
2
Introduction
Some Points to Keep in Mind
Not everyone starts from the same place in learning about Core Data (or, indeed,
any technology). Learning and developing with new technologies is rarely a linear
process. It is important to remember that you are not the first person to try to learn
these fairly complex interlocking technologies. This book and the code that you
experiment with try to lead you toward the moment when it all clicks together. If
you do not understand something the first time through, give it a rest, and come
back to it another time. For some people, alternating between the graphical design
of the interface, the logical design of the code processes, and the organizational
structure of the database can actually make things seem to move faster.
Here are some additional points to consider.
Acronyms
In many books, it is a convention to provide the full name of an acronym on its first
use—for example, HyperText Markup Language (HTML). It is time to recognize that
with wikipedia.org, dictionaries built into ebooks and computers, and so many other
tools, it is now safe to bring a number of acronyms in from the cold and use them
without elaboration. Acronyms specific to the topic of this book are, indeed,
explained on their first use in any chapter.
There is one term that does merit its own little section. In this book, as in much
usage today, SQL is treated as a name and not as an acronym. If you look it up on
Wikipedia, you will see the evolution of the term and its pronunciation.
Development Platforms

It is not surprising that the development of Mac OS X apps takes place on the Mac
itself. What may surprise some people, though, is that iOS apps that can run on
iPad, iPod touch, and iPhone must be developed on the Mac. There are many rea-
sons for this, not the least of which is that the development tool, Xcode, takes
advantage of many dynamic features of Objective-C that are not available on other
platforms. Also, Xcode has always served as a test bed for new ideas about develop-
ment, coding, and interfaces for the Apple engineers. Registered Apple developers
have access to preview versions of the developer tools. As a result, the Apple devel-
opers had access to features of Lion such as full-screen apps nine months before the
general public. In fact, Xcode 4 is optimized for Lion in both speed and interface
design.
ptg8126863
How This Book Is Organized
3
Assumptions
Certain things are assumed in this book. (You might want to refer to this section as
you read.) They are as follows:
.
Cocoa, as used in this book, refers to the Cocoa framework on Mac OS and,
unless otherwise specified, also to the Cocoa Touch framework on iOS.
.
iPhone refers to iPhone and iPod touch unless otherwise noted.
Formatting
In addition to the text of this book, you will find code samples illustrating various
points. When a word is used in a sentence as computer code (such as NSTableView),
it appears like this. Code snippets appear set off from the surrounding text.
Sometimes they appear as a few lines of code; longer excerpts are identified with
listing numbers so they can be cross-referenced.
Downloading the Sample Files
Sample files can be downloaded from the author’s website at northcountryconsulting.

com or from the publisher’s site at www.informit.com/9780672335778.
How This Book Is Organized
There are five parts to this book. You can focus on whichever one addresses an
immediate problem, or you can get a good overview by reading the book straight
through. Like all of the Teach Yourself books, as much as possible, each chapter (or
hour) is made to stand on its own so that you can jump around to learn in your
own way. Cross-references throughout the book help you find related material.
Part I, “Getting Started with Core Data”
This part introduces the basic issues of the book and shows you principles and tech-
niques that apply to all of the products discussed:
.
Chapter 1, “Introducing Xcode 4”—Xcode is the tool you use to build Mac
OS and iOS apps. It includes graphical editors for designing your interface
and data model. The current version, Xcode 4, represents a significant step
forward from previous development environments. You’ll get started by
learning the ins and outs of Xcode 4. After you use it, you’ll never look
back.
ptg8126863
4
Introduction
.
Chapter 2, “Creating a Simple App”—This hour walks you through the
process of creating an app from one of the built-in Xcode templates. It’s
very little work for a basic app that runs.
.
Chapter 3, “Understanding the Basic Code Structure”—This hour introduces
design patterns used in Objective-C as well as some of the features (such as
delegates and protocols) that distinguish it from other object-oriented pro-
gramming languages.
Part II, “Using Core Data”

Here you will find the basics of Core Data and its development tools in Xcode:
.
Chapter 4, “Getting the Big Core Data Picture”—Here you’ll find an
overview of Core Data and a high-level introduction to its main
components.
.
Chapter 5, “Working with Data Models”—Data models have been around
since the beginning of databases (and, in fact, since long before, if you
want to include data models such as the classifications of plants and ani-
mals). This hour lets you learn the language of Core Data.
.
Chapter 6, “Working with the Core Data Model Editor”—In this hour, you
will learn how to build your data model graphically with Xcode’s table and
grid styles.
.
Chapter 7, “What Managed Objects Can Do”—In this hour, you’ll discover
the functionality of managed objects and what you can do to take advan-
tage of it and to expand it.
.
Chapter 8, “Controllers: Integrating the Data Model with Your Code”—The
key point of this book is to show you how to link your database and data
model to interface elements and your code. This hour provides the basics
for Mac OS and for Cocoa.
.
Chapter 9, “Fetching Data”—Just as the SQL SELECT statement is the heart
of data retrieval for SQL databases, fetching data is the heart of data
retrieval for Core Data. Here you’ll learn the techniques and terminology.
.
Chapter 10, “Working with Predicates and Sorting”—When you fetch data,
you often need to specify exactly what data is to be fetched—that is the

role of predicates. In addition, you will see how to build in sorting to your
fetch requests so that the data is already in the order you need.
ptg8126863
How This Book Is Organized
5
Part III, “Developing the Core Data Interface”
Now that you understand the basics of Core Data, you can use it to drive the com-
mands, controls, and interfaces of your apps:
.
Chapter 11, “Finding Your Way Around Interface Builder: The Graphics
Story”—The Interface Builder editor in Xcode 4 (a separate program until
now) provides powerful tools and a compact workspace to help you develop
your interface and app functionality.
.
Chapter 12, “Finding Your Way Around Interface Builder: The Code
Story”—This hour shows you the graphical tools to link the code to the
interface.
.
Chapter 13, “Control-Dragging Your Way to Code”—A special aspect of
linking your interface to your code is using the tools in Xcode 4 to actually
write the interface code for you.
.
Chapter 14, “Working with Storyboards and Swapping Views”—One of the
major advances in Xcode 4, storyboards not only create and manage the views
and controllers that make up your interface, but also let you manage the
sequences in which they are presented (segues). You will find that storyboards
can replace a good deal of code that you would otherwise have to write for
each view you display.
Part IV, “Building the Core Data Code”
Yet another aspect of the connections between Core Data, your code, and your inter-

face consists of the data source protocol and table views. This part explains them:
.
Chapter 15, “Saving Data with a Navigation Interface”—Originally
designed for iPhone, navigation interfaces are an efficient use of screen
space for organized data. This hour shows you how to use them.
.
Chapter 16, “Using Split Views on iPad”—Split views on iPad provide a larger-
screen approach to data presentation than navigation interfaces. As you see
in this hour, you can combine navigation interfaces with a split view on iPad.
Data sources provide your Core Data data to the table view. This hour shows
how that happens and moves on to how you can work with tables and their
rows and sections. You’ll also see how to format cells in various ways.
.
Chapter 17, “Structuring Apps for Core Data, Documents, and
Shoeboxes”—This hour goes into detail about how and where your data
can actually be stored.
.
Chapter 18, “Validating Data”—When you use Xcode and Core Data to
specify what data is valid, you do not have to perform the validation your-
self. This hour shows you how to set up the rules
ptg8126863
6
Introduction
Part V, “Managing Data and Interfaces”
.
Chapter 19, “Using UITableView on iOS”—Table views let you manage
and present data easily. The UITableView structure on iOS is designed for
seamless integration with Core Data.
.
Chapter 20, “Using NSTableView on Mac OS”—NSTableView on Mac OS is

revised in Lion. The older versions of table views still work, but as you see
in this hour, some of the new features of UITableView have been back-
ported to Mac OS.
.
Chapter 21, “Rearranging Table Rows on iOS”—The ability to rearrange
table rows by dragging them on the screen is one of the best features of
iOS. It is remarkably simple once you know the table view basics.
.
Chapter 22, “Managing Validation”—This hour shows you how to build on
the validation rules from Hour 18 to actually implement them and let users
know when there are problems.
.
Chapter 23, “Interacting with Users”—On both iOS and Mac OS, it is
important to let users know when they are able to modify data and when it
is only being displayed.
.
Chapter 24, “Migrating Data Models”—You can have Core Data automati-
cally migrate your data model to a new version. This hour shows you how
to do that, as well as how to use model metadata and alternative types of
data stores.
Appendixes
.
Appendix A, “What’s Old in Core Data, Cocoa, Xcode, and Objective-C”—
There are some legacy features in the sample code you’ll find on developer.
apple.com and in apps you might be working with. This appendix helps
you understand what you’re looking at and how to modernize it.
NOTE
Due to the complexity of the topics discussed, some figures in this book are very
detailed and are intended only to provide a high-level view of concepts. Those
figures are representational and not intended to be read in detail. If you prefer to

view these figures on your computer, you can download them at
informit.com/title/9780672336195.
ptg8126863
7
HOUR 1
Introducing Xcode 4
What You’ll Learn in This Hour:
.
Understanding the new development paradigms
.
Exploring the Xcode workspace window
.
Defining projects and workspaces
.
Debugging with breakpoints
.
Caring for your source code with repositories and versions
The Origins of Xcode 4
Xcode 4 has its roots in Project Builder and Interface Builder, the two development
tools created for NeXTSTEP. The NeXTSTEP operating system ran on the NeXT com-
puter, which was manufactured by NeXT, the company Steve Jobs founded when he
left Apple in 1985. The hardware side of the business was not successful, and
NeXTSTEP morphed into OPENSTEP, which ran on Sun’s Solaris operating system,
and later on Windows. After Apple purchased NeXT in 1996, the software became
Rhapsody and, later, Mac OS X. A branch of the software became the iPhone oper-
ating system which, after the introduction of iPad, became iOS.
Project Builder and Interface Builder remained the developer tools through all this time.
Project Builder was the tool you used to write code, and Interface Builder was the
graphically oriented tool you used to draw the interface. Project Builder was renamed
Xcode in 2003; it contained significant changes to its user interface at that time.

At Apple’s 2010 Worldwide Developer Conference, Xcode 4 was given its debut. It
was released as the official version in spring 2011. One of its most significant fea-
tures was the integration of Project Builder and Interface Builder in a single tool.
This book is based on Xcode 4. If you are using an earlier version, it is time for you
to update to the latest software because by the time this book is published, Xcode
4 will be more than a year old (depending on whether you start counting from the
demonstrations or from the official release). Now that you know the history and ori-
gins of Xcode 4, there is no reason to distinguish it from its predecessors: From
this point on, it is simply referred to as
.
ptg8126863
8
HOUR 1: Introducing Xcode 4
Getting to Know Xcode
Everything you do in the development of Mac and iOS apps is done in the context
of Xcode. First demonstrated at Apple’s Worldwide Developers Conference in June
2010, it was released in several preview versions until the final release in the spring
of 2011. Xcode 4 is not just a revision to the interface of Xcode 3; it is a rethinking of
the way in which developers work on their apps.
This hour helps you understand this new way of working and why it is so relevant
to apps written for Mac and iOS in today’s world. Not only will you find out how to
use Xcode 4, but you will see why it is structured the way it is and how you can best
take advantage of its new features.
As you use Xcode 4, try to use the new features and new ways of working so that
you understand what the people at Apple think a productive development process
can look like today. And bear in mind one important point about Apple’s developer
tools: for many years, these tools have been testing and proving grounds for new
ideas about interface design. What you see in Xcode 4 includes some novel
approaches to interface design that you may consider using for your own apps both
on Mac and iOS.

.
One of the most important features of Xcode is its simulator: software that
lets you test iOS apps on your Mac. You’ll find out more about the simula-
tor in Part II of this book, “Using Core Data.”
Goodbye “Hello, World”
For many people, their first program was something along the lines of the well-
known Hello World program shown in Listing 1.1. It is from the classic The C
Programming Language by Brian Kernighan and Dennis Ritchie (1978).
LISTING 1.1 Hello, World
main( ) {
printf(“hello, world”);
}
Many people still think of this as a model of what programming is all about: You
start with a blank piece of paper or a blank screen, you type in your code, you run
it, you make revisions, and you continue on to the next program on its own blank
piece of paper or blank screen.