Customer Reviews

Learn Cocoa on the Mac (Learn Series)

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

 

 

The "gold standard" for learning Cocoa programming has been Hillegass's book Cocoa(R) Programming for Mac(R) OS X (3rd Edition) for a long time. However, it is slightly in need of revision. This book is a worthy supplement or even an alternate - the style is quite different, a bit more playful. Nutting, LaMarche and Mark have done a great job of explaining some of the whys and wherefores of doing things the cocoa way and have the advantage of working with Leopard and Snow Leopard. So this is a bit easier to follow and doesn't run into the "xyz is deprecated" debugging notes (so much, there are still a few!). However, Hillegass is determined to make sure his students think, so his book has problems for the reader to solve, some of which are pretty challenging and have several solutions. This book takes a "here's how you do it, why you do it this way and read the manual for anything else". Different folks will have different views as to which book is better - I think that they complement each other quite well and are both well worth reading. I find I learn different things from the two books and regard them both equally.
The authors give a very thorough coverage of bindings and Core Data. I was not aware of the fact that you can drop a datamodel entity into Xcode to obtain most of the nuts and bolts of a fully functional application, completely automatically. This alone was worth the price of the book - a clear explanation for binding and methods for dealing with large datasets (not covered elsewhere, even in the excellent Cocoa Design Patterns. For the cocoa programmer, this almost puts Xcode up as a simple alternative to Filemaker, although the latter has a slew of built in features that would be hard work to implement directly in cocoa.
This is a strongly recommended book for the slightly above novice programmer (you do need to know the basics of C) wanting to jump-start learning cocoa to the fairly experienced programmer who needs a refresher on bindings and core data.

There are plenty of reviews of the content so I'm just going to review the aspects of this book specific to the Kindle. However, my star rating is for the ebook as a whole as it would be unfair to penalize the content because of the conversion to the Kindle.

As usual, the publishers have made a poor effort at conversion and should be ashamed of themselves.

The images are at too low a resolution. Many of these images are intended to show the state of various user interface widgets so that you can make sure they match up with what you have on your screen. But these images are at too low a resolution to see what's going on and it's a real strain to compare. This applies both to reading the Kindle version on a Kindle device and with the Kindle app for the Mac.

The code examples have been converted as images. This means you can't search within the code examples and that when you adjust the font, the size of the code sample font (which is pretty small) can't be adjusted. In addition, when the code samples span a page boundary of the original text, they appear to have been scanned as two separate images with one placed atop the other. No attempt has been made to make the two images line up, so the code examples have random alignment changes in the middle of them. In at least one case the person doing the conversion failed to notice that two blocks of code were separated by a block of regular text meaning that the whole lot appears in the ebook as one image with the intervening text appearing as an unadjustable, unsearchable image too.

None of these issues could possibly have been missed if there were any attempt at proofreading whatsoever. In this age of hyperbole you might be tempted to read that as an exaggeration. I mean it literally. It's clear that nobody at the publisher had no more than a glance at the result of conversion before this was shipped to Amazon for downloading. That's a pity. The print version is attractively presented and the content isn't bad either.

And of course it's frustrating that the book is full of boilerplate code that I'd really like to just copy out of the ebook into Xcode, but I can't do this.

This is the first time I've tried to use an ebook as a programming tutorial. On the plus side it has this great advantage: I could run the Kindle app on the secondary display and never have to worry about repeatedly forcing the book to lie flat. So it's much more convenient to use than the print version.

Jack Nutting has played, worked and turned Cocoa (and it's NeXTStep predecessor) inside out since the 80s. You can see that. He knows not only how but also why. And he shares that knowledge in this book.

Cocoa is a huge scope. An introductory book must select what is most important to learn first. This book does that. Furthermore, it is a great introduction to Conan O'Brien and Andy Richter...ehh, I mean Xcode and Interface Builder. The only thing that the book demands is that the reader has basic knowledge in Objective-C.

One of my principles as a writer is that more pictures and fewer words, doesn't make it harder to grasp - quite the contrary. This book is richly illustrated with screen shots, and the language is both simple and efficient.

This is a book for those who finally want to start to implement a killer app for the Mac desktop.

I'm a big fan of Apress books as I find they offer very good value for money. I visit the Apress site on regular basis to check out upcoming titles on iPhone and Mac development. There was one book that was announced quite some months ago, but the release date kept slipping and slipping.

That book is called "Learn Cocoa on the Mac".

First of all, I'd like to point out that this book does *not* cover iPhone development. This is about Cocoa and Mac applications. Of course, with Cocoa Touch being a subset of Cocoa, you will recognize design patterns that you use on the iPhone and of course topics like Core Data can be used in both Cocoa and Cocoa Touch.

The chapters in this book are:

1. Must love Cocoa
2. Hello, World
3. Lights, Camera... Actions!
4. GUI Components
5. Using Table Views
6. Cocoa Bindings
7. Core Data Basics
8. Core Data Relationships
9. Search and Retrieve Core Data with Criteria
10. Windows and Menus and Sheets
11. Document-Based applications
12. Exceptions, signals, errors and debugging
13. Drawing in Cocoa
14. Advanced Drawing Topics
15. Working with files
16. Concurrency
17. Future paths

I'm not going to go through all the chapters in detail as the titles are clear enough.

You can see that the base of subjects is *very* wide and that is what makes this book a really great one. I find the explanations of the subjects and the samples really great. I felt really comfortable and got more confident going through this book, occasionally going through chapters very fast because of my knowledge of Cocoa Touch.

The nature of this book is really great. We all know that there are dedicated books on subjects such as Core Data and graphics. However, "Learn Cocoa on the Mac" does a great job of giving great introductions and clear explanations of what is going on. It goes deep enough into its subjects to make you understand what's going on.

I love this book. I had great expectations of it and it didn't disappoint. This goes easily in my personal top 3 of Cocoa books.

When I worked with the author of "Learning Cocoa on the Mac", Jack Nutting, at Integrity Solutions in St. Paul, Minnesota in the mid-90's, I had the strong sense that we were part of a very special group of people, at a very interesting time in the software business. The NeXT computers and software we were using to develop applications for our customers were years - perhaps decades - ahead of their time, and we felt convinced that NeXTSTEP was poised to dominate the enterprise software industry. Thanks to the power of NeXTSTEP's software frameworks, we were able to develop powerful, user-friendly, mission-critical software with astonishing speed and effectiveness. Furthermore, NeXT seemed to be taking the technology in a direction that would allow for much greater adoption, as it worked to develop versions of NeXTSTEP for SPARC and Intel processors.

Then came the World Wide Web, and the dot-com boom. Desktop applications gave way to Web-based applications, which made much more sense for big enterprise deployments as well as (of course) "consumer-facing" applications. For a while, NeXT's WebObjects (now the framework that powers Apple's iTunes Music Store and MobileMe web services) was the framework of choice for big enterprise software projects.

Then Apple bought NeXT, and Steve Jobs returned to Apple as CEO. Jobs quickly realized (to his credit) that if Apple was going to survive and prosper, it needed to focus on the consumer market. Sun's Java and Microsoft's ASP quickly rushed in to fill the void as Apple abandoned its support for OpenStep and enterprise development. NeXT's advanced technology became the foundation of Apple's OS X, and the future of the platform became intimately linked with the success of Apple's hardware.

Many NeXTSTEP developers simply accepted these changes and moved on to other platforms. A stalwart few however (like Jack) kept the faith and continued working with these awesome tools right through to the present day. Today, a growing number developers are being attracted to the Mac platform as Apple keeps turning out great products and increasing its user base. In recent years, the stunning success of the iPhone has given rise to a new generation of Objective-C developers creating great apps for the consumer market. This book is perfect for experienced developers wanting to develop software for the Mac, whether they be newcomers or NeXTSTEP old-timers returning to the fold.

It's hard to fully appreciate the power, beauty, and simplicity of the Cocoa frameworks until one has spent some time working with its alternatives. In the Microsoft world, VisualC++ and .NET provide similar functionality, but with far less elegance and a much steeper learning curve. In Java, AWT and Swing have nothing like Interface Builder, and the various Java layout managers are notoriously complex and difficult to work with. And web-based technologies such as Flex and ExtJS are only now just starting to rival the Cocoa UI frameworks. On the back end, Apple's CoreData framework, drawing on years of engineering done on its ancestor, NeXT's Enterprise Objects Framework, is unsurpassed as an Object Relational Mapping (ORM) tool.

Happily, this book (unlike so many others in this category) doesn't spend several chapters reviewing the history of computing back to the bronze age. Neither does Jack fill up several chapters extolling the virtues of Cocoa and its NeXTSTEP heritage. Instead he jumps right into the meaty stuff.

Jack's writing style in this book strikes a perfect balance between entertainment and substance. There are abundant useful tips sprinkled throughout, introduced at just the right time. This is not intended as a reference book; it's meant to be read from start to finish. Even if you already have some exposure to Cocoa or iPhone development, you will learn new things along the way.

Any book on a living, breathing technology like Cocoa is bound to be somewhat obsolete before it is published, and this book is no exception. Apple released Snow Leopard as this book was being written, so the author was challenged by having to deal with the significant changes from Leopard to Snow Leopard. In addition, while the book is primarily about writing desktop apps, it also attempts to document some of many important differences between the iPhone and desktop SDK's, though it could perhaps go a bit further in this regard - for example, when introducing a major new class or concept, we aren't always told whether it's desktop-only.

Learning Cocoa on the Mac walks the reader step-by-step through the process of building several "real" (albeit somewhat whimsical) applications. It starts by building out the user interface (View), then moves into the Controller layer, and finally covers the Model layer via CoreData. Concepts such as Key-Value Coding are introduced in the context of these projects, which really helps them "stick", as opposed to introducing them in an abstract way and hoping the reader will apply them later. This approach demonstrates good OO design principles and shows how the various parts of Cocoa map to the "holy trinity" of MVC.

While Learning Cocoa covers several of the "assistants" built into XCode, which can automate some aspects of programming, it also covers powerful high-level concepts such as Cocoa Bindings and the Responder chain in great detail. Whenever an automatic or otherwise seemingly "magical" technology is introduced, Jack always takes pains to explain what's going on under the hood. This isn't a book for entry-level programmers who just want to dip their toes into Cocoa; Jack gets you in deep with the technology, but always in a patient, clear, and thorough way. This book is destined to become a classic. I recommend it without hesitation.

Chapter 1, 2,3 were all good and very informative. The pace of the first three chapters is appropriate if you are learning Cocoa. Most of the chapters are under 30 pages and cover one topic. Chapter 4 covers the GUI components. It covers ALL of them at once and intertwines them with code all in one program. In Chapter 4, the authors decided to change how they performed the instruction (guidance). Figure 4-15 is impossible to read even with magnifying glasses. Way too much is covered in this chapter. They cover almost every type of GUI NSObject in Cocoa, the connections in X-Code, Cocoa and Objective-C all at once. They should think about going a little slower. I lost my confidence at page 79. I couldn't read figure 4-15 and then trying to make the Classes work was impossible. I put the book down after getting to page 89 and none of the code worked anymore. I will eventually get on the website ([...]) and download the working program for chapter 4 and start up again in chapter 5 (have to since the application make in chapter 5 is based on the chapter 4 developed application).

I hope they consider moving a little slower, perhaps make 3 chapters out of chapter 4. There are a lot of GUI components. There's a lot to do with the interactions between the Class and the GUI components. The GUI is one aspect, connecting the various GUI Objects and class/methods interaction is another, and then pulling it all together with Objective C is another. It was all covered in this one chapter.

I'm just a little annoyed right now. I will add more to this little review some other time. I hope I can give it more stars (it was pretty good...except for chapter 4). This is the second Apress book that I tried to read and had to put down (because of the same frustration). The editors need to spend the time and do the code in EVERY chapter (Not just look at what the authors provide, but what EACH chapter details). Apress needs to have someone do the code in every chapter...not just the first three chapters. Apress will get better product if they do that.

Nutting, Mark, and LaMarche have created an amazing book for learning Cocoa and building solid, interesting applications for the Mac. I have worked with the Hillegass book extensively, but I really wish I had found this book first. The style is much better suited to the way I learn things.

The authors really understand how programmers think, and they present the major features of Cocoa in ways that encourage experimentation. When you finish a section, you really feel like you understand what is going on, because they go out of their way to explain the WHYs and HOWs behind the code, even mentioning what happens when you do things incorrectly.

When I learn a language, I like to learn about individual tasks, write code to deal with those tasks, play around with the methods I learned, and then move on to the next thing. This book provides a great set of tools that can be used for just that kind of experience. An absolute must-have for anyone trying to write software for the Mac platform.

One note: This book might present some difficulties for new coders. It's essential that you understand basic programming logic and structures before diving into this. Because of its reliance on Objective-C, a firm grasp of Pointers is a must.

The examples are basic and very tedious, and there are more typos than there should be. There is a section on Objective-C but a lot of details are left out.

I really enjoyed this book.

As with all books...there are good points and bad points...but overall, the book provided me with the information I needed as a reference for starting development on a Mac using Xcode (I've come from a PC and Linux background).

If you buy this book...you wont regret it.

The difficulty in commenting on tech manuals is that the bar is set so breathtakingly low. If rated against objective standards of useful organization, coherent, readable writing, good graphics, and smart implementation of sound educational techniques as well as accurate and useful information, "Learning Cocoa on the Mac" deserves a C+ at best. But what does that really mean in a field where the norm is a D-? Near as I can tell, the glowing reviews of programming documentation are all examples of grading on the curve - any book that can play chopsticks gets an A+ because the rest of the class is screaming and pounding on the keyboard with their fists.

Here you have the usual: a book that was obviously written as fast as humanly possible, given an even faster and shallower edit, and laid out so badly that you wonder if perhaps the designer wasn't paid off by some manufacturer of migraine medication. This last, in particular, should be used in classes on designing procedural layouts as an example of a train wreck on paper. A details analysis of what's wrong with the design would be nearly as long as the book. But given that nearly all technical manuals are hastily written, poorly designed, and cheaply printed, and that any number of the links on this page are to even less successful efforts, is it fair to trounce this one?

I've no idea, really. It's a social problem on par with trying to establish literacy standards for a population crippled by fetal alcohol syndrome which spends its spare time huffing glue. What's clear is that the publishing industry is slanted toward producing hundreds of redundant books, each more mediocre than the last, because doing so is profitable. The only ethical approach toward the whole mess is theft. If I have to drink corn syrup because the food industry has decided they'll make more money by selling nothing else, I'll be d*mned if I'm going to pay them for it.

Most tech books can be downloaded elsewhere in 15 minutes, free of charge, and I recommend doing so. If you find the result useful, send the author a check. The rest of the time, you can at least mutter "Thank God I didn't encourage anyone to waste trees on this bilge" as you drag yet another file into the trash.