Customer Reviews

The iPhone Developer's Cookbook: Building Applications with the iPhone 3.0 SDK (2nd Edition)

5 star:		(18)
4 star:		(6)
3 star:		(0)
2 star:		(3)
1 star:		(1)

 

 

I am new to iPhone programming and wish this book had been available a year ago when I started down this path. For people who are starting out, I would buy this book after you've worked through Mark and LaMarche's Beginning iPhone Development published by Apress. The only way to really learn a programming language/paradigm is to work through writing your own code. With a book like this, you can quickly find snippets from recipes that move you beyond the basics for your own programs.

Compared to other computer "cookbooks" (such as those published by O'Reilly, for example), this one has much more background material than recipes. Think of it as a book on iPhone programming with lots of examples. People who are more interested in recipes than learning about the iPhone SDK might be disappointed, but I can't see how. I have yet to find something I don't like about this book.

Finally I also appreciated Ms. Sadun's writing style. The book is very readable, and I think she understands that people new to programming technologies can be overwhelmed by new concepts and new nomenclature. Simple, straight forward language means that people who are experienced programmers won't be weighed down a lot by overly wordy explanations, while newbys like me will gain a lot by putting new concepts into simple terms.

Being a new iPhone developer, I had begun my study of the craft with the help of a couple Objective-C books and the experience of developing and publishing a small and simple app. I was ready to take on some bigger ideas and needed some help with discovering the best practices for the common things app developers seek to do. I made the mistake of trying to find a couple good beginner books to get a leg up. What I found was that there are dozens of somewhat remedial iPhone development resources that all offer good information that only take you just beyond "Hello World". I really wanted something meatier that was still accessible to a newer developer. I found that in this book.

Though I've only had for a couple days, I'm already thrilled with how chock full of practical and usable recipes are here. I love the author's tendency towards programmatic solutions as opposed to using IB and templates. I'm looking forward to dog-earing pages and using the heck out of this. I wish I had an electronic copy as well.

I'm a college professor looking for a book to use in my iPhone programming course. This would be a very poor choice for a new student. The book teaches poor iPhone programming style and isn't written for people new to the platform. I felt like I was tricked by the other positive reviews. I honestly think this author and a few other authors made a pack to give positive reviews for each other's book. There are better options for people new to iPhone programming. Keep looking.

For example: Who puts hundreds of lines of code into the main.m file? Are you joking? Apple says everywhere to follow a suggested programming style. This should be 100% of main.m every time...

#import <UIKit/UIKit.h>
int main(int argc, char *argv[])
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
int retVal = UIApplicationMain(argc, argv, nil, nil);
[pool drain];
return retVal;
}

Learn it. Love it. Use it.

btw I've been watching Matt Stroker's videos available on iTunes U from the University of Utah. They are free and a much better introduction. (Obviously the Stanford iTunes U iPhone videos are good too.)

I had been struggling with iPhone app development for a couple of months, using the Apple documentation and the Dave Mark/Jeff LaMarche book. I'm not the world's most brilliant programmer, but I've been around IDEs before and I just didn't expect it to be this difficult.

Then I picked up the Cookbook, and the world crystallized into clarity. Erica showed me how to cut the crap and NOT use some of the Xcode "features" that had been making me crazy. She showed me exactly what Interface Builder was doing for me (and to me) and how I could use only the parts I wanted. With her guidance, I deleted most of the files created by the "helpful" New Project templates and put everything into main. She cleared up my confusion about the model-view-controller paradigm by explaining that Apple was using the words but not really sticking to the philosophy.

I'm now making progress on my app instead of screwing around with the mechanics.

Erica Sadun's book and code are excellence itself. I started out with Sams Teach Yourself iPhone Application Development in 24 Hours, which is a fine book. However, as someone with several years' coding experience (and none on Apple platforms), I could have jumped right into this book and found everything I wanted or needed.

The examples build on each other, starting from the simplest implementation to rich and complex ideas. However, even the first example in each chapter is grounded in a few pages of background information. This provides the context for using a control or class that is often missing from Apple's documentation. And the complex examples are useful and not contrived. Unlike tutorial books that might stick with an app idea and reuse it past its useful life, Sadun strikes a thoughtful balance between building on the code that has come before and breaking out with a new code base.

Finally, the online repository of the source code is a goldmine. The author has taken the time to continue to revise her code as she or her readers report issues.

All in all, an outstanding tome. I am looking forward to the inevitable (I hope) iPad + iOS 4 update.

It can be very frustrating trying to step into the iPhone/iPad world. There are plenty of "Hello World" examples, but after that it starts getting very confusing very quickly.

Worse, some of what you'll find is out of date - the SDK is a constantly moving target and even if it were not, there are so many different ways to accomplish the same goal that it's very hard to know what the best approach is for your particular project(s).

I suppose this book is already out of date. I'm still going to recommend it, because it really helped clear up some things I was very confused about.

The author doesn't recommend this as a rank beginners book. You'll need some "Hello, world" experience first and perhaps a bit more. However, I'd recommend buying this at the same time as you buy those getting started books because the first hundred and fifty pages or so really will help you understand things the beginners books don't mention at all.

I read the negative reviews and I understand that there may be flaws here from the viewpoint of more experienced or more pedantic reviewers. That's OK - Erica's book helped me and I'm quite sure it would help others.

By the way, because I've reviewed so many books and maintain a large technically oriented website, I often get books like this free as reviewer copies. This isn't one of those: I paid for it and definitely feel that it was worth the price.

Excellent reference to "Cookbook" style program techniques and snippets. Written for the intermediate programmer, provides insight into the tricks, tips and techniques of writing Objective-C for the iPhone platform.

The quality of the explanations, presentation, and organization of the topics covered by this book are excellent, but the utility of the book is ruined by the meat and potatoes of the content- the source code itself.

If you know enough Cocoa Touch to make sense of the source, the book won't be of any help to you. If you're trying to learn Cocoa Touch, you'll spend 90% of your time trying to make sense of the code instead of learning the putative subject at hand. If and when a beginner does figure out what's happening, they'll learn how to approach problems in manner that's guaranteed to get their app rejected, waste their time duplicating effort, and crash and burn horribly when an API changes.

Instead of following best practice design patterns, the source code inexplicably is stuffed into main.c with no commentary, uninformative variable names, and inconsistent formatting. More importantly, the code is technically lacking- it's full of memory leaks, release calls to zombies, and unnecessary HIG violations. Instead of fixing the deficiencies of the snippets, the publisher has taken the tack of releasing the code as "open source" (sic), meaning that you're supposed to do their work for them by submitting corrections to the code that should have been fixed before inflicting it on others.

Bottom line: A competent editor and a less disingenuous publisher could probably make this into a much more useful book, but that isn't the case for the current edition. Ignore the glowing reviews posted by Erica's fellow Conde Nast contributors, it's obvious that they haven't actually used the book.

I first LOVED the first edition of this book. I like how she dealt with all sorts of interesting and off the road stuff. At first I was disappointed with this book because it did not have the hackery of the first edition but when I finished it , the book was so well written and had such interesting topics that it is my favorite iPhone book. I have read and re-read it several times. Also , Erica is the rare bird that actually checks and rechecks her work. The examples and writing should be the gold standard all computer books should be written too.

[Note: This is a preliminary review, based on my early experience with this book. "Better early than never."]

This second edition of The iPhone Developer's Cookbook: Building Applications with the iPhone SDK is a major rewrite of the first edition. It is more than twice the size of the first edition, and even the original material has been extensively revised.

It may well be a better introduction to the subject than the first edition was. But it is intended mostly as a reference book. While many of the other available books may be useful as references, they are intended mainly as tutorials. My brief experience with this book indicates it is a better reference than they are.

I will give one example: In preparation for the rumored Apple tablet / iSlate, or whatever, I would like to know about how to determine the size of the screen on the device the application is running on. I looked up "screen" in this and six other books (Beginning iPhone 3 Development: Exploring the iPhone SDK, More iPhone 3 Development: Tackling iPhone SDK 3 (Beginning), iPhone SDK Development (The Pragmatic Programmers), iPhone Application Development For Dummies (For Dummies (Computer/Tech)), iPhone SDK 3 Programming: Advanced Mobile Development for Apple iPhone and iPod touch (Wiley), and Head First iPhone Development: A Learner's Guide to Creating Objective-C Applications for the iPhone), using each book's index.

While most of the other books mentioned that the screen was 320x480 pixels, and some of the others discussed implications of designing an application for a device with a small screen (albeit larger than most cell phones), *none* of the others gave any help toward finding out the screen size of the current device. Sadun's book (second edition) explicitly mentions that upcoming hardware may have differently-sized screens, and the index points to a section which gives highlights of the UIScreen class - including a paragraph on how to find out the screen size.

The other obvious place to get detailed information like this is Apple's documentation. A search for "screen size" at Apple's iPhone developer web site returns many results, but unfortunately, the first page or two of results are not helpful.

Happily, a search in Xcode's documentation window *is* helpful. I searched for "screen size", and the third hit was the class reference for UIScreen, which gave essentially the same information as Sadun's book. But I like the way it's presented in the book.

Note: The book was apparently finished before the September 2009 introduction of new iPod touches and iPhone OS 3.1. But from the programmer's standpoint, the newer OS introduced mainly some relatively minor changes in audio and 3D graphics, and the new iPod touches introduced nothing new (except a larger maximum memory size).

(Sadun has apparently addressed some or all of the criticisms of the first edition. However, I have not yet examined the book thoroughly enough to determine whether she has completely banished the use of methods (etc.) which Apple would not approve of, and I am not experienced enough to judge the quality of her code. My rating of the book might therefore go up or down one star (probably not more than that) when I am more familiar with it.)