Product Description

Develop your own iPhone applications

Ideal for non-Mac programmers, this introductory guide shows developers how to create applications for the world's most popular smart phone. You will learn how to use�a modified version of�the Mac development environment, the Objective-C programming language, and the Xcode development tools.

Nearly every chapter of iPhone SDK Programming: A Beginner's Guide consists of a self-contained project, with the corresponding Xcode available for download and modification. The book is designed around the concept of accomplishing specific, discrete programming tasks for deployment on the iPhone.

Product Details

• Amazon Sales Rank: #187628 in Books
• Published on: 2009-08-04
• Original language: English
• Number of items: 1
• Binding: Paperback
• 512 pages

Features

• ISBN13: 9780071626491
• Condition: NEW
• Notes: Brand New from Publisher. No Remainder Mark.
• Click here to view our Condition Guide and Shipping Prices

About the Author

James A. Brannan is a J2EE Java developer and a Mac OS X shareware developer.

Customer Reviews

Not recommended
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)

Great Book for Beginners
I am a non-computer professional doing web development as a hobby. I am totally new to Mac programming. I tried a number of books and a few video tutorials to learn iphone SDK programming. I though I understood those well but I realized it was still very difficult when I tried to do real life my own programming. Then I started reading James Brannans iPhone SDK Programming book (a week ago). I am still half way through the book. But I could not stand the idea of not commenting on the book. This is a really good book. It is easy to read, fun to read, contains absolutely practical oriented examples. I am now building my own applications much more easily than building on modifying others example files. I am now on the tract. I highly recommend this book for beginners!!!!
Thank you James Brannon,

Chandana Karunarathne

Nice examples - pretty clear text
This book has well thought out examples that are nicely presented. It presents some key topics that most books shy away from, and it presents them clearly. Most notably, it has a good example of an app with a table within a nav bar within a tab bar. This is a very common app pattern and is presented here clearly and with good explanation. I don't think any other book does this quite as well.