Customer Reviews

Cocoa Programming Developer's Handbook

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

 

 

I have a pretty solid background of C on unix and bare-metal embedded systems but I'm very new to Mac OS X; you should take that into account when you read the review.

The book has a distinct feel that it was written with the C programmer in mind. The book tells you all about the Objective-C messaging and objects but it keeps emphasising that Objective-C is not a substitute but an addition to C. If you read the book "Cocoa Programming for Mac OS X" by Aaron Hillegass you can very easily put together simple applications using XCode. However, if you have a deeply entrenched C background, you will feel lost a bit, because you don't know what's going on. Now this book tells you exactly that. It explains all the major Cocoa classes and the messaging but does it in a way that makes sense with a purely C background.

There are a couple of typographic errors in the book that are rather distracting. Code listings are line numbered and the text refers to the line numbers when it explains the workings of the code. The problem is, the numbers do not always match. You may have a listing of lines 1 to 20 and the text pointing out the clever trick used in lines 76 and 80. The code that the text refers to is all there, it's just the line numbers that are wrong. Obviously, when the text was written the author had a longer piece of code and later decided to remove all unimportant lines before the function in question, but forgot to update the references. At a few places the text simply doesn't make sense, apparently the author decided to rephrase a couple of consecutive sentences and haven't finished it. As expected, you have half-finished sentences, not forming a logical chain of thought.

Nevertheless, those problems are not show-stoppers. When you encounter them, you'll need to put some extra effort in deciphering the actual meaning or working out a listing offset. It is a distraction and a quite annoying one, but you can get the information.

Overall, this book will help you to understand the features and inner workings of Objective-C, the organisation of the major Cocoa frameworks and classes. It explains the Cocoa event system in depth and prepares you to feel comfortable with XCode even if you come from a non object oriented, "vi, make and gdb are the best development environment" centric background. After this book you can use the book from Aaron Hillegass and you will actually know what will going to happen in your code if you drag this thingy over there to that thingy in the interface builder, as per Aaron's instructions.

Furthermore, the book explains the differences between Objective-C 1.x and 2.0, the changes to Cocoa over the various OS X versions and shows how to write code that is backward compatible as well as forward compatible, i.e. not dependent on features that Apple might remove in future OS X versions. It also explains the differences between the Apple and GNU versions of Objective-C so that you can write code that is at least partially reusable on the GNU environment.

An important note: This book is not for iPhone development. Where the iPhone and OS X are different, the OS X version is explained but the iPhone is not. In such cases there is always a warning about the difference and usually some advice about achieving the same outcome on the iPhone, but you will need to consult iPhone specific documentation.

The book assumes that you are fluent in C and you have at least a vague idea about what object-oriented design is all about, even if you've never done any OO programming. You do not need to know Objective-C but, again you *do* need to know C to understand the book. Furthermore, having familiarity with event-driven programs, though not a requirement, will help. The book explains how events are delivered, but not the design philosophy behind event driven systems.

The book gives you a historical background regarding to OS X, Objective-C and Cocoa. It describes the (not always rosy) relationships between the Free Software Foundation, NeXT and Apple. It also explains how the GNU and non-GNU tools, old Apple technologies, NEXTSTEP, BSD and the Mach kernel are rolled together to form OS X. The history is written in a very readable style, telling the facts and explaining the business and politics behind the decisions. Nevertheless, this part of the book is very concise, it just "puts you in picture". The rest is highly concentrated information, written in an easy to follow, readable style but without fluff.

In summary, if you want to do OS X Cocoa development and you know your way around in writing software but you don't have an OO background then this is an excellent book, which I recommend to be read before any of the other Cocoa development books.

This is one of the best books that I have read on Objective-C because it actually informs the reader of what is going on behind the scene's. I will say that this book takes more of a Computer Science approach to the language than a programming approach, so anyone that is reading it to learn the language may want to read something a little more elementary first and come back to this once they've written some applications and become more familiar with the language (I suggest Cocoa and Objective-C: Up and running which is simple enough for any student to understand). This is an amazing textbook for anyone studying or working in Computer Science.

This is a very good book if you are scientifically inclined. One of my pet peeves with Apple's documentation is that it tends to be heavy on API details and code snippets but does not clearly explain how the technology actually works. It seems that many CS authors have confused Data Hiding with Knowledge Hiding, and never take the pain to explain anything in detail. Don't get me wrong, I'm all for Data Hiding as a software-management technique, but please don't hide conceptual details-- without that, it becomes extremely hard to reason about the correctness or performance of the program. (For example, Apple's Core Data documentation keeps rambling: "you will normally not need to do XYZ so we are not going to explain what we are doing." (e.g., how does Core Data manages memory internally, and why are there two set of KVC methods, such as valueForKey: and primitiveValueForKey, and under what circumstances does the framework call which set of methods. Well after spending some quality time with DTrace, you can figure it all out, but the reason people read books and documentation is so that they don't need to spend time running DTrace and IDA Pro.)

What's nice about this book is its emphasis on conceptual details. In particular, the chapters related to Objective-C (and Obj-C runtime) alone are worth every penny. Also, the book tries to tie together a lot of different things which you will need while building an application. Normally, this kind of knowledge is hard to get unless you have worked with a team of software engineers (I'm a research scientist, so I never had this opportunity, but I have learned enough from this book that I can build a full fledged Cocoa application). Also, almost all of the code samples that I downloaded from the authors web-site compiled and worked in XCode4, which is a big win.

That said, the book is not without some minor flaws. There are quite a few typos--even in the code snippets in the book! Also, a more in-depth overview of Complex UI design (in addition to what's there in chapter 11) would be extremely useful. In any case, I highly recommend this book for anyone who knows how Cocoa works, but would like to go a bit deeper.

This book provides a great deal of information, but the delivery is directed towards an audience that has some xcode and cocoa 2.0 programming experience already. Having said that, the discussion of mac programming is very thorough with many examples given. The text is a bit dry at times with explanations of what things are rather than how to implement them into your own works. Overall, a good reference book for things you may want to explore that you haven't gotten around to yet.

I'm still working my way through this book. It's very thick, but so far, I've gained a solid base of knowledge on what Objective-C can do. The example code is excellent and not full of errors like some programming book's code I've bought. My only concern is that I've skipped ahead and the base is all you get really. It's up to you to fill in the blanks, and decide what to get next to learn more about Mac|iPhone programming. I'd recommend a good Cocoa book to go with this.