iPhone SDK Programming: A Beginner's Guide [Paperback]

I feel quite sorry for anyone using this as their main, or even worse, sole, resource from which to learn iPhone development. There many small niggles with the book and some material errors.

Annoyances:

- the code presentation, whilst using monospaced font, uses short indentation (usually two spaces) and makes almost no use of whitespace lines to separate methods, declarations etc. Conversely, methods are written with extra inline spaces in places where there usually is none.
- there is an underlying assumption that the reader will be familiar with Java, with many references such as "Java does x", or "Java doesn't do y" etc.
- inconsistent use of the terms 'function' and 'method' which should really be kept quite separate at this level.
[- there is no @package compiler directive in Obj-C (p47). Furthermore, even bringing in @private, @public, and @protected at the start of the book needlessly complicates things.]
[NOTE: this was an error on my part, and I apologize for that. There is indeed an @package directive for 64-bit implementations. This is covered in some Apple docs, but not in others (see discussion thread below for further comments)].
- the chapter on C, whilst it would make a useful appendix if it was written well, is billed as a refresher. Some, perhaps many, people coming to iPhone programming may have some Java experience, but it's a fair bet that many do not have C experience and really need a different treatment than a C 'refresher'.
- needless disquisition on C pointers etc. It would be fair to discuss the asterisk syntax in Obj-C and mention that it relates to C pointers, but the new programmer is probably well served to treat classes and objects in Cocoa/Obj-C at their face vaue as OO constructs and not bother digging too deeply into their C antecedents until they're well advanced in their studies.
- there is a tendency to explain points - sometimes quite intricate points - using the same kind of language and technical wording as is made in the original point.
- there is no need to go into the definition of Obj-C categories in the early part of the book - it's too much, too soon. The same point applies somewhat to discussion of dynamic binding, dynamic typing, method overloading, method overriding, inheritance (yes, they can be covered but the approach taken is really quite blunt and seems to assume a lot of background knowledge).
- wordy, and ultimately very confusing, discussion of why using @property/@sythesize (more generally, accessors/mutators) helps with memory management. The underlying point is valid but the choice of when and how to tackle it seems quite misguided.

In marked contrast to three other books* in the beginner category I feel this author fails to empathize with his target audience or really understand what their aims are and where their conceptual problems might lie. There is an awkwardness and distance in the treatment of the subject and a tendency to 'throw the kitchen sink' at the reader that I think could really cause some problems down the road.

The really annoying stuff:

- comments about MM on p9: "You can use something called autorelease, which makes memory management a little easier, but even autorelease is not recommended". Autorelease isn't about making memory management easier, per se, but even then the author goes on to use it in contrived situations, despite warning against this (see below).

- using -retainCount method (p55) when it is widely understood to be of no use to the app programmer and cautioned against in the apple documentation (the author does put a note stating "there is no reason to call retainCount" but it is plainly misleading to state "I use retainCount to illustrate Objective-C memory management" - it's one of the worst ways to do this).

- setting up your own autorelease pool to bypass the supposed problems with memory management (p59). To get over the "tiresome and error-prone" manual managing of reference counts the author creates an autorelease pool, puts an object into it, and then releases the pool. All this instead of simply releasing the object itself after he has used it.

- in the protocols discussion (p74): "Remember, in Objective-C, you send a message and if nobody can handle the message, nothing happens." This is misleading, particularly if taken out of context. It's true that certain methods can be made optional in protocols (unlike, as we're told, with Java interfaces) so not implementing the optional methods will cause no harm. In general Obj-C terms, though, sending a message that can't be handled or forwarded will lead to a runtime crash.

There are enough half truths, misconceptions, inconsistencies and outright errors of fact in this book to really sow the seeds of confusion and doubt amongst its readership. I have returned my copy of the book to Amazon for a refund as I could not recommend it for any courses I teach.

*strongly recommend instead (any two of the three would give a good grounding with an alternate viewpoint):

Goldstein's Dummies book
Mark and LaMarche's iPhone dev book (SDK 3.0 version)
Pragmatic Programmers iPhone dev book (due to be released Sep '09; pdf has been available for many months)

I have gone through the first few chapters, and I am just confused! I have some programming background, and have actually done some sample iPhone apps in the past, but I have not had one example in this book work. For example...the "Try This" on page 28 says "In Groups & Files, create a new folder named c_code." Unfortunately, there is nothing telling me how to do this, and all of the usual Apple ways of accomplishing this do not work. It would be nice to have a little more clearly-defined instruction in this, since this is a book targeted at "beginners."

I think the most frustrating thing was after the first exercise, the book acknowledges that the exercise is confusing, but assures the reader that by the end of the book it will make sense. Sure, I feel like an idiot...wouldn't it be more effective to build my confidence in the first exercise, rather than drag me through an exercise that doesn't work, that I don't have enough experience to troubleshoot? I still can't figure out why it's not working.

On the next page, it says "Open main.m, import cwork.h, and add the sayHello method to the file (Listing 2-4)." Does this mean that I need to go to the file menu and import, or is it by typing the instructions in Listing 2-4 accomplishes this? The jumping around in chapters to find these "Listings" is really confusing...I'm not sure why the information is discussed on one page, but the actual code is listed several pages later. It might have made more sense if the methodology was described in the Intro...this is the single most frustrating problem with the book. It keeps telling you to go to "listings" of code, but it's not clear whether you're adding the code to existing code, or replacing it.

Also, when I "Build and Go" it would've taken the author two seconds to tell the user that the Console is found under the "Run" menu. I kept waiting for a window to pop up with results, but couldn't understand why nothing was happening.

I'll keep trudging along, but I can say at this point I'm frustrated, and about ready to toss the book and start over with a new one. Sorry to be so harsh, but I really don't see yet how this is considered a "beginner" book. I'll be returning the book this afternoon and looking for something that's a little more straightforward. By the fourth chapter, It's still not making any sense.

I would like to say that this book is great. It's definitely a great book for beginners.
The book teaches how to do the basic stuff such as navigation controllers, table views and simple stuff such as buttons, images, view controllers, etc.
However, I noticed this book seemed to be rushed...for example, the author teaches how to make the navigation bar disappear
using the viewWillAppear method but then doesn't tell you how to get it back and where to place code (PAGE 178).
I found out that you must incorporate setNavigatioBarHidden:NO animated:YES to view didLoad method in the second view controller just to get the Navigation Bar back.
It was frustrating to search through the net and then figure it out on your own.

I recommend this book for absolute beginners, who would like to tinker but not for production.
Although the author has written a decent book, I hope that the author realizes that improvements are needed such as:

1) Completing methods when they are introduced.
2) Help the reader understand why they are doing some things introduced.
3) Check the book for logical reasoning in the reader's perspective, such as the aformentioned navigationbar.
4) If a publishing company rushes the author to print an unfinished book, then the author needs to find a new publisher.

› Go to Amazon.com to see all 13 reviews  3.2 out of 5 stars