Xcode 3 Unleashed, Part I

This post is the first in a series reviewing the book Xcode 3 Unleashed , by Fritz Anderson.

I hope you’ll find the approach to this review to be informative, as it will definitely be different from other technical book reviews. Much longer than most book reviews, there is a good reason: to provide depth of information about the book, including quality and relevance of the examples/code, describe where the book shines, and also to point out areas for improvement.

For this and all book reviews, I’ll take the time to read the book (cover to cover), work through numerous examples (as in, type in code, compile, run, etc) and share my insight from the perspective of someone who has been in the software business (as a techie) for nearly 20 years. As the author of a technical book, I’ll also be able to put myself in the shoes of the author, which I think can provide for some additional insight regarding what works and what doesn’t in a book. Once the review is complete, I’ll write one or two posts (tips) that are based on information from the book. Let’s get started.

Part I: The Life Cycle of a Mac OS X Application
The first section of the book walks through most all aspects in a typical application lifecycle, from designing (with Interface Builder) to version control to unit testing (to name just a few of the topics covered).
Most all examples in this section revolve around one application, a linear regression example. The first few chapters work through coding the application to allow for user input of data points (input to the regression example) using the command line. From here the book dives into the Model-View-Controller design pattern. The model, view and controller objects are explained in relation to building upon the linear regression example. There is a chapter devoted to each topic, which provides a great deal of information not only on working with Xcode, but includes good material on MVC for those who are new to writing applications using this approach.

Once a basic working application is built, Fritz dives into creating a Subversion repository and integration of the same within Xcode. There is a fair amount of groundwork before one can use Subversion, and each step is covered in detail. I found that coverage of the more subtle nuances helpful, such as preference settings to exclude specific file types from being included in a repository.

Property lists, libraries, targets and file packages/bundles are covered next, each topic having its own chapter. The author does a nice job of building upon the linear regression example, and incorporating new concepts into the project. For instance, when talking about libraries, a C library is created to calculate regressions. To round out the library discussion, the author demonstrates how to add an additional target to the build process as well as making one target dependant on another, ensuring the most current version of the library is always used.

Attention to detail continues throughout the first section of the book, working through topics such as unit testing, documentation, data modeling. As with the work so far, the mapping of topics to the linear regression example continues. Case in point, the library built earlier has some limitations, so Fritz describes how to morph the library into a framework, a structured directory tree for managing header files, resources and the like.

For the most part I found the step-by-step descriptions and examples to be both accurate and effective. I did encounter several figures in the book that didn’t match the current version of Xcode (I have the latest release installed). However, I know from experience when writing technical content it’s no trivial undertaking to keep screenshots current with software releases. Differences that I did encounter did not inhibit working through the examples.

Let’s wrap up this this part of the review with a listing of the Table of Contents for Part I of the book:

Part I: The Life Cycle of a Mac OS X Application

Chapter 1: Kicking the Tires

Chapter 2: Simple Workflow and Passive Debuggin

Chapter 3: Simple Active Debugging

Chapter 4: Compilation: The Basics

Chapter 5: Starting a Cocoa Applicatio

Chapter 6: A Cocoa Application: Views

Chapter 7: A Cocoa Application: Controllers

Chapter 8: Version Contro

Chapter 9: Property Lists

Chapter 10: Libraries and Dependent Target

Chapter 11: File Packages and Bundle

Chapter 12: Unit Testin

Chapter 13: Creating a Custom Vie

Chapter 14: Dynamic Libraries and Framework

Chapter 15: Documentation in Xcod

Chapter 16: Using the Data Modeling Tool

Chapter 17: Cross-Developmen

Chapter 18: Spotlight (or, How to Build a Plug-in)

Chapter 19: Finishing Touches

In the next post I’ll continue the review, focusing on the second half of the book, XCode Tasks .

  1. These kind of reviews are really helpful. After reading your review I decided to pick up the book. There appears to be several iPhone books on Amazon … but none that are published yet. I wonder if this is because of the annoying NDA.

    – Rodney

  2. Hi Rodney,

    I can answer your question about books in the wings…the answer is yes. I am on the technical reviewer list for several iPhone related books, and each of the publishers I am working with are waiting on the NDA.

    John

  3. Yeah, they can’t publish because of the NDA. I’ve heard some of the authors complaining about it in some more private forums. Very annoying. They can’t even really give the books to beta readers.

    Great idea for an in depth book review. Overviews don’t do much good for coders unless they keep hearing about it everywhere, like Hillegas.

Comments are closed.

  • Related Content by Tag