Programming Cocoa with Ruby: Create Compelling Mac Apps Using RubyCocoa (The Facets of Ruby Series)

This is a book for the Ruby programmer who's never written a Mac app before. Through this hands-on tutorial, you'll learn all about the Cocoa framework for programming on Mac OS X. Join the author's journey as this experienced Ruby programmer delves into the Cocoa framework right from the beginning, answering the same questions and solving the same problems that you'll face.

Together you'll build a single application that threads throughout the book, and it's not a toy. You'll cover topics that may not be the flashiest parts of Cocoa, but they're ones you'll need to know to create robust, feature-rich applications for yourself. And you'll learn more than just Cocoa and RubyCocoa, you'll get first-hand effective agile development practices. You'll see test-first development of user-interface code, little domain-specific languages that take advantage of Ruby features, and other Rubyish tricks.

At the end of the book, you'll be ready to write a real Mac OS X application that can be distributed to real users.

User review
Reads like my pair,,.
I am just learning Ruby and I use a Mac - it just made sense that I should combine both things.

Also, I'm quite skeptical of learning from a book - I prefer learning with a person as a pair.

I loved Brian's style - it is written (or I read it) as though he was sitting across from me (or beside me!) as my programming pair, he explained WHY he did stuff the way he did and it all made sense. It is not technically loaded, but a friendly and jovial style (which really works for me).

It really is a great step-by-step manual to creating good apps on the Mac - I can see that it works at many levels (beginners - like me, would love it because it explains each line of relevant code, intermediate folk will like it because it gets a little deeper into some things)

And the best thing about this,,.it gets you into the habit of writing software in a highly effective way, with tests and harnesses and all the great stuff that good craftsmanship is all about.

Do I recommend this - you damn right I do!

User review
Immediately Useful and Thoughtfully Written
This is exactly the kind of thoughtful, useful technical writing I have come to expect from the `pragmatic bookshelf` series. Brian Marick's conversational writing style makes the subject immediately approachable: In just a few pages the first ruby/cocoa application is up and running, providing the reader a great incentive to dig deeper.

And deeper the book digs. I was expecting a good amount of Ruby and perhaps just enough Cocoa to be dangerous, however, the depth of Cocoa coverage this book provides is staggering for its size. I daresay that for the average programmer, this book could replace a lot of the unfriendly Cocoa documentation available from Apple. The author has clearly gone to great pains to research this subject and the reader benefits from that leg work, with many of the pitfalls and gotchas of Cocoa revealed before they become problematic.

The pace of the book is brisk, but I found it about right for the subject. As with all of the pragmatic books, the reader is spared from lengthy diatribes on language history, irrelevant trivia and interminable minutiae associated with some software books. I did not feel short-changed for length either; the book weighs in at ~370 pages plus an extremely useful glossary, which serves as a very handy desk quick-reference.

Unfortunately, RubyCocoa is already fast becoming a slightly obsolete technology, as the author acknowledges in the introduction. MacRuby will be upon us soon. However, given the depth of Cocoa information in this book I would still encourage any Ruby developer who intends to work seriously on desktop applications in RubyCocoa to absorb the basics from this book before hiding behind the MacRuby facade.

User review
Solid introduction to Cocoa
This book is exactly what it claims to be: an introduction to Cocoa for people who already know Ruby. It also has some good examples of test-driven design using Shoulda.

Some of the Interface Builder instructions will need to be updated for 3.2. (I ended up switching to IB and Xcode 3.0 just so I could follow along.) Additionally, the author develops his own domain-specific language (or DSL) and uses this throughout the rest of the book. I see the value of a DSL in creating shortcut methods for some particularly chatty Objective-C-style methods, so I'm glad he talked about it. But using this in all his examples means that if I want to borrow from his code for future projects, I'll also have to include his DSL, or re-invent parts of it myself. I think listing out the actual Cocoa calls might have been clearer.