Customer Reviews

Core Animation for Mac OS X and the iPhone: Creating Compelling Dynamic User Interfaces (Pragmatic Programmers)

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

 

 

I bought this book based on the rave recommendations I read here. And with the limited selection of books on the topic, this one seemed like the best one available at the time (June 2009).

I have to report that I was disappointed with this book. The author's style is a tad repetitive. Often the text would promise explanations of something "in detail", but the detail never came.

Generally the book scratches the surface of many elements of Core Animation, giving the reader a reasonable starting point for further research. But since the text of the book does not include complete code examples (just snippets) it is sometimes hard to see how the examples would fit into a larger application.

I am an accomplished software developer with over 20 years experience designing complex software applications. I have read (at this point) more than few serious books about Objective-C, Cocoa, and iPhone development. I learned little from this book, sadly. Except that I need to buy another book.

Bottom line: If you are already a Max OS X and Cocoa developer, then this book will be a good introduction to Core Animation. But you will need to read more than just this book to get up to speed. If you are an iPhone developer, the one chapter in this book about iPhone specifics as they relate to Core Animation is not worth it.

Core Animation is one of the coolest technologies to come out of Cupertino in many years. It makes doing all sorts of cool things in your application not just possible, but downright easy. Core Animation opens up worlds of possibilities for your applications' user interface.

The problem is, Core Animation is not intuitive. Even an experienced programmer can expect to spend a lot of time with Apple's documentation before he or she will grok the terminology and concepts of this new framework well enough to use be proficient.

Fortunately, the author has already gone through the trouble of doing that and has taken the time to break it all down into digestible chunks, explaining the concepts and terms in plain English, and setting out exercises that reinforce your understanding of those concepts.

As previous reviewers have mentioned, the bulk of the book focuses on using Core Animation when writing Mac programs, however both the basic concepts and the practical use of Core Animation are the same when programming the iPhone. The iPhone chapter explains the differences between using it on the two platforms and shows how to apply the stuff you've already learned earlier in the book when developing on the iphone.

I think this book probably reduced the amount of time I needed to learn Core Animation by at least half, probably more, and I'm an experienced programmer who's accustomed to learning from Apple's documentation.

Just a quick note of something that's probably obvious: You should already have a decent grasp on Objective-C and Cocoa before picking up this book if you want to get the most out of it.

I got this title just to get a feel for the animation capabilities and how the APIs are for this platform. The book was just fine for that. The author's style is fairly readable, and he has a good tone.

I think any graphics book really should be in color; it makes a big difference, and trying to teach animation in a book is tough anyways. The reason to buy a tech book is to learn something away from the computer (IMO), so it can be hard to learn animation this way.

Would I recommend it? Hard to say. Depends on what you're after. He does have some good tidbits for folks to go beyond the mechanics of animations and think about the experience the animations provide. I think that could be handled more deeply, too.

So, take a look at the TOC, read a sample chapter, and decide if you think it's for you.

I thought this would be a focused book on core animation, with examples for the iPhone. I was extremely disappointed in what seemed to me as if the iPhone coverage was a single ten page chapter at the end of the book, without one full-length program for use on the Phone.

This book is probably good if you are focused on Mac OS programming, and just want the details on core animation. It is also probably pretty good if you already know Mac and want to apply what you know to the iPhone and you know the differences between the two platforms.

However, I was disappointed, in the fact that most of the coverage was on Mac and only the additional short chapter specfically covered iPhone, without one single full code listing for the iPhone.

There are those who say that if you know Mac, you also know iPhone. However, the truth is that iPhone is a subset of Mac, and when you just read about Mac development, you don't necessarily know what applies to the iPhone and what does not. Discussion of hardware specific features (think touch screen vs. mouse) and output (think windowed large screen vs. full-screen views of a small screen) made it hard to relate the Mac examples to the iPhone environment.

At 175 pages with large type, and for this price, it does seem that one gets alot less for this book than other books that cost this amount. I waited until I read the entire book to write this. I have even given it a little extra time, to see if I would come back to it often as a reference, for detailed information on specific animation topics. I have not. Overall, I feel let down by The Progmatic Programmers -- the publishers of this book.

This book gives a good introduction to the Core Animation framework and some of the slick ways that you can spice up a Cocoa app for Mac OSX or the iPhone. Its assumed that you know your way around Xcode, and that you know the basics of Cocoa programming. So if you are new to Cocoa you may want to have a copy of Cocoa Programming for Mac OS X handy.
Cocoa(R) Programming for Mac(R) OS X (3rd Edition)

The book gives a good overview of the Core Animation framework, and helps to get you through some of the less intuitive parts. It walks you through a few different examples of developing animation apps for the mac and then explains the differences and limitations of writing for the iPhone.
I would also suggest reading through the apple docs at http://developer.apple.com/documentation/Cocoa/Conceptual/CoreAnimation_guide/

Personally, I was hoping for a more thorough review and examples for the iPhone, and was dissapointed that there are like 14 pages in the iPhone chapter, and 7 of them are a full page of a single image. (I think that might have something to do with the time the book was written and the state of the NDA for iPhone developers, but still I was disappointed)

Overall, I think the book gives a good start to some animation concepts, and ways to improve your iPhone apps.

Now I'm looking for something that can give me a good overview of using OpenGL for the iPhone or something like blender or unity3d.

Core Animation is a powerful new Apple technology that debuted with Mac OS X Leopard. As it was later revealed, it was a technology that originated for the iPhone.

Core Animation is actually comprised of two different technologies:
1) An animation technology
2) A layering (compositing) technology

Core Animation makes it easy to animate a "view" object from point A to point B without having to write your own animation loop or timer callbacks. It can be as simple as just saying "move there" and Core Animation takes care of the rest.

The layering aspect is the part that caught my attention as an OpenGL developer. Basically, you can think of Core Animation as a textured rectangle engine, i.e. apply a 2D image on a quad, and then can transform it (translate, rotate, scale). Apple leverages OpenGL under the hood so this is all really fast...much faster than the traditional techniques which are CPU oriented instead of GPU oriented. But the real leverage of the technology comes from the fact that you can turn on Core Animation for any existing Apple widget so you can use their buttons and various views instead of reinventing the wheel making your own 2D image quads (not to mention event handling/responder chain).

Furthermore, because OpenGL is used as the back end for Core Animation, it is now finally possible to intermix previously unrelated UI pieces together in a single view. So for example, before it was really hard to superimpose an OpenGL view with a Quicktime view and a Cocoa view for building a sophisticated UI. The "layering" part of Core Animation is now the grand unification technology that allows all this to just work together because all can now be rendered via Core Animation layers which is all OpenGL at the bottom. (The technology was originally called LayerKit before Apple renamed it to Core Animation.)

I find this particularly compelling for building UI interfaces. Before I might do a lot of the hard painful work of writing 2D stuff in OpenGL directly that required fluid animation and speed. But now Core Animation provides a simple API to do this and already provides me powerful capabilities such as rendering high quality text (always a pain in OpenGL).

Unfortunately, documentation is hard to come by for Core Animation. I think it has hurt its adoption rate.

Enter Bill Dudney who has addressed that shortcoming by writing the book "Core Animation or Mac OS X and the iPhone".

Bill Dudney covers it all, from simple animation and layer-backed views (i.e. using Core Animation with traditional NSView's on Mac) to using Core Animation layers directly for more powerful and expressive capabilities.

For anybody needing to deal directly with Core Animation, I think this book is a must-have.

However, I have seen some criticisms of the book, mostly from iPhone developers. So I want to be clear on what this book is about (or not about).

This book is specifically geared towards Core Animation, not Cocoa or iPhone programming in general. (Dudney is working on a general iPhone book which is worth looking at.) And knowledge of just Core Animation is not sufficient to build an entire application. This book is best suited for those people who want to make superior and elegant UIs to differentiate their products (or simplify implementation in my case), and not settle for run-of-the-mill looking UIs. For example, he builds a simple Front Row like interface as one of his more advanced code examples. But also to be clear, as much as I wish we had such a thing, this is not an elite Cocoa tips & tricks book or gems book so the focus is learning Core Animation (via mostly simple isolated examples), not doing elaborate example projects.

There is a single chapter on iPhone at the end of the book. There are not a lot of differences between pure Core Animation on Leopard and iPhone, so iPhone doesn't really need a whole lot of discussion. However, this also underscores that the book was really written with a Mac centric focus. The first section of the book covers using Core Animation with NSViews which is an important topic on Mac, but irrelevant to iPhone developers. When the book moves into dealing with Core Animation layers directly, this information is directly applicable to iPhone developers. But I can understand that iPhone developers may experience frustration at needing to work with Mac examples in these sections rather than iPhone examples. But the examples are fairly simple and to the point so you generally don't need to focus on the infrastructure differences between Cocoa and Cocoa Touch. Still, if you are an iPhone only developer, you might want to hold off on this book purchase unless your need to understand Core Animation is great and you can live with the fact that a significant portion of this book does not apply to you.

One other criticism I've seen is that the photos in the printed book are not in color. I can say that the e-book version is at least in color, though I personally don't think color is all that important for the topic material. (You might argue motion is important for animation, but I don't know how to address that in book form, short of making a flip-book.)

I do hope he will do something to address the new features in Snow Leopard and newer versions of iPhone OS whether it be a blog entry or an update to a book.

The author clearly understands Core Animation (CA) technology, and his selection of topics provides an interesting overview of CA. However, the book is poorly focused, and it makes the concepts difficult to absorb. The book jumps around concepts and breaks basic rules of technical writing and editing. For example, he will refer to a technology like Quartz Composer, but the definition appears later in the book. The book provides an interesting array of examples, but cherry picks from the extensive APIs. The book would have been better served by providing overviews of the APIs, and tying the examples into the API. This lack of reference and context is disorienting. You get isolated examples, but you feel you lack the bigger picture. Overall the book is moderately satisfying, and an interesting introduction to the technology. But is insufficient to understanding the breadth of Core Animation. It is barely a 101 primer.

I wrote up a long, detailed breakdown of the failures of this book on my blog at [....], but here's the short version.
The book needs a few things to be successful, especially in light of the new crop of Cocoa developers coming around thanks to the iPhone. Most start with the definitiveCocoa(R) Programming for Mac(R) OS X (3rd Edition) by Aaron Hillegass and move on to learn about specific framework technologies. As such, certain stylistic and programming conventions that have come to represent "Cocoa programming best-practices" are not adhered to at all. Sample projects are lazy in scope, despite the author's stated intention to "spark our imagination." Sample code is often full of ivars and methods that aren't even used in the project. No memory management seems to be used at all. Code fluctuates between using "traditional" bracket notation and dot notation from project to project. And I could go on...

The author's writing is incredibly redundant, and the book could use an editor who isn't afraid to slash and burn. There are long passages that say nothing, and certain concepts and statements that come up again and again. Where on the one hand the author wants us to feel free to make "gaudy" things to learn how to integrate Core Animation into the future of interface design, he spends the better part of the book warning us against doing exactly that. He seems truly terrified that he's unlocking Pandora's Box upon the development community and will be personally held responsible if things start going wrong in Cocoa projects from now, forward. I humbly suggest this isn't the author's role in my life as a developer.

Perhaps my biggest beef with the book is that its target audience is ill-defined. It is definitely not an introduction to Cocoa, but it also tries too hard to hold the hand of more experienced developers. So its too easy for those with Cocoa experience, but too hard for those without experience.

I would really love to see this book re-imagined as a logical next-step from the Hillegass book and dig in deeply to Core Animation. Develop three or four deep, original projects, explain the code development in detail, build on the best-practices Hillegass teaches, and cater exclusively to a development community that understands Objective-C and how to use the Cocoa frameworks without fear.

Core Animation is a new technology in Mac OS X Leopard that has not been as widely adopted as I would have expected, I believe in large part because of the lack of documentation for it. This book is the only printed guide devoted to the topic, and I have found it invaluable in the development of several products. The Pragmatic Programmers series of books are always written and edited well, and this is no exception.

It is assumed that you are already familiar with Objective-C and the Cocoa APIs at the start of the book, so learning those fundamentals is required for new Mac and iPhone developers. The book also progresses as if you were an existing Mac programmer who will gradually incorporate more and more of Core Animation into your applications. This might cause a little impatience from those who want to jump right in to working with some of the more advanced capabilities, but those people can easily skip ahead to the relevant sections.

All of the important concepts are covered, although a couple of the tricks that I frequently use in my Mac and iPhone development are not mentioned. This is understandable, as they are not documented well and I only learned them from other developers. iPhone developers may be a little disappointed in the relatively small iPhone-only chapter, but that's simply because layer-based animations and the like are handled identically between the Mac and iPhone and there's little that is unique in the iPhone's implementation of Core Animation.

Source code examples for all exercises in the book are available at the publisher's website [...] and they contain many useful code snippets.

This book has earned its place on my desk.

I got this book following reading some mostly positive reviews and because needing to grasp the technology while jumping with time constraints I wanted to find an effective way to get the most out of Core Animation (CA) in reasonable time through an easy tutorial. Boy was I disappointed by this book.

It seems that the adage: "color tastes are different for everyone" is even more true judging by my deceptive experience compared to 5 star reviews that some people have posted here.

First to clarify things: the book is outdated, and that's the sad part of every book where the author has taken the risk to add real code examples. But it seems unfortunate that when the book was written, some of the features were already in development and the publishers didn't postpone the publication to include those.

MacOS X/iPhone: Let's face it, most people will buy a book like that to develop an app on the iPhone (150K apps in appStore compared to hundreds of apps on MacOS X. It's also very unfair to write a Core Animation book for MacOS X, then add a dozen pages chapter (no. 12) at the end for iPhone and then add that it's for MacOS X AND iPhone in the title on the cover. Lame! Core Animation was written for iPhone. And iPhone has very subtle differences with MacOS X especially for the beginner (layers have a different coordinate system, layers are implicit in views on iPhone, some technology like Core Image for filtering are not there, OpenGL is implemented in a different way, etc... Heck! Even Apple as of this reading still didn't update the coordinate system origins in their own documents. So just going through the document without even understanding what works and doesn't work on a specific platform is asking for too much for an introduction book.

What bugs me down the most about this book it the non-pedagogical aspect of every chapters and paragraphs. It's not inviting, the layout is awful and you are exposed to concepts that are not even explained (google to the rescue.) I mean if I have to google up and go back to Apple docs just to follow up a tutorial session, why should I buy this content in the first place.

Core Animation is a terrific technology, it's tremendously slick and it shines on the iPhone even more. I really wish there were a decent book on the market to do it justice. I have yet to read the other one from Zarra&Long, but when I do, I'll post a review there too. In the meantime, I'll stick with Apple website and a few other Cocoa blogs.