Cocoa Design Patterns
by Erik M. Buck and Donald A. Yacktman
The most important work on design patterns in software development was published 15 years ago and the structure of the Cocoa framework has also been in place for a considerable number of years so, although there’s very little wrong with this book, I’m not certain who makes up the target audience. Are there enough intermediate-to-advanced Cocoa developers who are unaware of the broader world of object-oriented development?
The material here is dry, even by the standards of computer books but, to be fair to the authors, I don’t see any way around that. By nature, the list of patterns with their descriptions and uses forms an encyclopedia of class and object structures. It’s interesting for reference and understanding the material will likely make a developer into a better designer in the long run. But, as the back cover specifies, “Cocoa Design Patterns painstakingly isolate 28 design patterns” (emphasis mine).
The quality of the writing is generally good. There are places where some lack of proofreading is noticeable , but not to the point of distraction or misunderstanding.
Learn XCode Tools for MacOS X and iPhone Development
by Ian Piper
Here’s a book that was a pleasant surprise compared to my expectations of it.
I’ve used XCode — and whatever it used to be called — since receiving the OSX public beta late in 2000. Like any large piece of software, however, it has features that I’ve never had a reason to use and others that escaped my notice when they were included. I figured this book would be fun to skim and see if I could pick up a tip or two.
As it turned out, instead of just being a rehash of obvious menu items and options (as too many application-specific books are), this one has entire chapters devoted to task-oriented solutions such as source code management, testing, and performance analysis, specifically how they’re integrated into the XCode tool set. Other sections describe the functioning of external applications and utilities that are related to XCode but are often overlooked by developers. My major complaint about that treatment is that it was too brief, leaving many of those utilities unexplored.
Overall, the writing style was clean and engaging. Although it didn’t make any promise of being a book about the actual coding of computer programs, I found the code examples here to be better constructed than in many books that are nominally on that subject. I like that the author does not insult the intelligence of readers by padding; one detailed example of a concept, followed by instructions to do the same thing in each similar case, suffices.
Two points come to mind on the negative side:
– frequent updates to XCode render any book of this type inaccurate quickly and obsolete in a fairly short time.
– it’s a relatively thin book that still leaves some of XCode’s more esoteric features untouched. (I guess I’ll have to read Apple’s documentation of it after all.)
Beginning iPad Application Development
by Wei-Meng Lee
Here’s another book aimed at people who are new to programming for an iPad. In this case, there’s an explicit recommendation that the reader should already be a programmer with some object-oriented experience.
I found the writing style and the book’s organization both to be far clearer than the majority of what I’ve read recently. I appreciate the organization of material from simple and basic to more complex and specialized. Even though not much of it was new to me at this point, I still picked up some tips. The treatment of different iPad project types within the selection of XCode templates and their purposes was something I would have found very useful a few months ago.
There are a few negatives to watch out for, however.
1) Though the proofreading of the text is far better than average you’ll still need to watch out for some instructions that don’t make sense (e.g. “insert the bold lines in the following code” followed by a block of code with no bold lines) and code in the explanations that doesn’t match the equivalent code in the program listing.
2) There’s a substantial amount of padding where code listings are printed once for entry and a duplicate is printed a few pages later for explanation. I guess technical books need to be thick to justify their cover prices.
3) The coding does not show much attention to memory management or protection against run-time errors. On one hand, making even a small program error-proof is a big task which might detract from the lessons being taught. On the other, I find crashing programs to be an embarrassment. Since the book does not claim to be a programming reference for novices, I guess I can be forgiving on the point.
In general, I think this is a good book if you fit the target reader profile…and don’t mind doing some debugging.
iPad Application Development for Dummies
by Neal Goldstein and Tony Bove
This book succeeds in explaining some specifics of how iPad programming differs from iPhone programming in spite of its frequent typos, coding errors, omissions, and inconsistencies. I would expect someone coming to this book without a decent background in development, preferably Mac development, and strong debugging skills to drop it in frustration before reaching the end.
The book presents one complete application and significant portions of another to show its concepts and, in that, does a good job of providing the reader with information about how the parts contribute to the whole. Examples of integrating web information and local information are especially well done.
Beyond trivial mistakes in text that could have been caught by proofreading, the most annoying problems with the book are the poor development practices that are presented. A partial list:
- Variable and method naming is inconsistent and usually not informative about the element’s purpose. (e.g. Naming a ViewController as ‘
- Superficial and useless documentation of code. (i.e. Describing
webView.delegate = self; as the assigning of a delegate.) If documentation is necessary, it should say ‘why’ rather than ‘what’. Otherwise it’s word count padding.
- Frequent coding examples that use variables, constants, and methods before declaring them. This is especially annoying when XCode as a tool has the ability to recognize declared elements but does not have the ability to create declarations automatically.
- Memory management is not considered seriously and the resulting samples demonstrate a variety of leaks.
In summary, my opinion of the book’s value depends strongly on the target audience. For an experienced programmer who is willing to read between the lines and and accept the flaws as the product of a rushed demo, there’s lots of good information. I suspect, though, that someone who is a true “Dummy” won’t be any wiser when they’re done with the book.
iPhone SDK Programming
by Maher Ali
The best thing about this book is that the author dives into the actual subject material of the iPhone SDK without a great deal of lead-in filler. There are only two chapters of Objective-C and collection class background, followed immediately by real UIKit and related material.
The worst thing is the author’s decision to avoid the use of Interface Builder in all of the sample applications. The claim that this low-level approach is better for understanding the workings of an application is silly. Interface Builder is the practical method for creating and connecting UI elements and the one that developers should be familiar with. Showing the code equivalent once would be interesting, but avoiding use of such an important tool entirely reduces the utility of the book significantly and results in cluttered code examples that have at least a passing resemblance to bad Swing.
The second aspect of the book that seems poorly considered is a lack of object-oriented design principles within the code itself. I understand that the examples are toy applications that serve only to illustrate simple concepts, but habits such as poor naming conventions and broken encapsulation of objects serve only to reduce the reader’s trust for the author’s reliability.
I suppose it’s petty of me to also pick on the number of typos and grammatical mistakes in the book since that seems to be the overall state of publishing now, but I haven’t come to terms with this new reality and it’s still annoying. As with my previous point, the sloppiness here does nothing to advance an impression of authority for the material.
If there were no other iPhone programming books around, I might look back at this one for samples of using SQLite or RSS, but I suspect that won’t be necessary.
Mobile Design and Development
by Brian Fling
As a complete contrast, this wasn’t a book that I was looking forward to reading with the same sense of practical urgency as the above, but one which I enjoyed immensely due to a clear writing style and a logical treatment of the material.
The content approaches a more strategic level, appropriate for entrepreneurs and those looking at corporate product planning. The author focuses on defeating the problem of market fragmentation because of incompatible platforms. His solution is to recommend web applications over native ones where at all possible. Having a primary interest in iPhone development and no interest in lowest common denominator solutions, that means that many of the technical methods described are only of background interest to me. If I ever need that architecture, I know I have a good reference for it.
Apart from that, I gained an interesting upgrade in my knowledge of mobile technology, its history, various capabilities, and limitations. I may have also gained insight into the value of considering how and where a user may employ an iPhone application as an element of that application’s design.
Again, a very well-written design guide, especially for those contemplating web sites that provide information that may be of particular use to mobile devices.
The iPhone Developer’s Cookbook
by Erica Sadun
Here’s another hands-on development book that starts out by showing how applications can be created as code-only, but in this case we’re relieved of that encumbrance by the time we get to chapter three. Another appealing feature of this book is the context provided for the various examples. Instead of being a catalogue of API calls implemented in isolation, the author provides reasons for why these uses of the programming library might be valuable.
Taking a “cookbook” approach means providing recipes that address specific developments needs. The ones supplied here look to be general enough to be useful for anyone getting involved in iPhone development. I appreciate the fact that tips are included that make the results look professional, for example: the use of icons and images as PNG files with transparency, and timing recommendations for animation effects. All of the chapters that specifically touch on the user interface and interaction with the device seem very clear and well designed.
For almost any book, there are things that the reader wishes were better. In this case, the author makes a point of noting that the memory management in the examples is not optimal due to changes in the SDK while the book was being developed. Likewise, the decision to put all code into a single file for each example rather than distributing it across individual header and implementation files is an obvious shortcut that doesn’t reflect good practice. Additionally, chapter ten, which attempts to cover such things as web services, SQLite, XML, the keychain, and file transfer in about thirty pages, is rushed and terse.
Overall, I enjoyed this book as an instructional work. There is a new edition currently available for pre-order with updates for the version 3 SDK. I will be getting a copy, not only to see how the author treats the additional subject matter, but also to serve as a reference resource.