Xcode 3 Unleashed, Part I

What follows is the first post of three, 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.

Ill 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, Ill 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 doesnt in a book. Once the review is complete, Ill write one or two posts (tips) that are based on information from the book. Lets 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 didnt match the current version of Xcode (I have the latest release installed). However, I know from experience when writing technical content its no trivial undertaking to keep screenshots current with software releases. Differences that I did encounter did not inhibit working through the examples.

Lets 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 Ill continue the review, focusing on the second half of the book, XCode Tasks.

Please follow and like us:

Leave a Reply

Your email address will not be published. Required fields are marked *