- Series: Developer's Library
- Paperback: 456 pages
- Publisher: Addison-Wesley Professional; 1 edition (September 11, 2009)
- Language: English
- ISBN-10: 0321535022
- ISBN-13: 978-0321535023
- Product Dimensions: 6.9 x 1 x 9 inches
- Shipping Weight: 1.3 pounds (View shipping rates and policies)
- Average Customer Review: 40 customer reviews
- Amazon Best Sellers Rank: #173,497 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Cocoa Design Patterns 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
Praise for Cocoa Design Patterns
“This long-needed book is a great resource for Cocoa newcomers and veterans who want to get the why behind the what. The list of patterns gives historical perspective and answers many developer questions and the last three chapters–covering Core Data, AppKit, and Bindings–are a must-read; they reveal insights that might otherwise require hours of discussion with Apple engineers or access to source code.”
–Tim Burks, Software Developer and Creator of the Nu Programming Language, www.programming.nu
“This book is a comprehensive and authoritative treatment of design patterns and their practical applications in Cocoa projects. I recommend this book to anyone who wants to advance from intermediate to expert proficiency as a Macintosh developer.”
–John C. Randolph, Vice President Engineering, Stealth Imaging, Inc.
“Cocoa Design Patterns is a fantastic book that will show you the ins and outs of software design patterns, how Cocoa makes use of them, and how to apply them to your own applications for better, more robust, and more maintainable software.”
–August Trometer, Owner of FoggyNoggin Software
“Cocoa Design Patterns is superb! It is highly readable, thoroughly enjoyable, and filled to the brim with wisdom that will make you a more efficient and effective programmer. The authors utilize a consistent and self-contained approach to each chapter, making it easy to return to use as a reference. However, the material is so interesting and vital to Cocoa programmers that you’ll want to read it from cover to cover.”
–David Mandell, Independent Developer
“Erik and Donald’s book really helped me out with the conceptual side of programming. It caused me to realize where I was going wrong in my code and helped me sort out my design issues.”
“This book is recommended for any programmer interested in a deeper understanding of Cocoa. Reading it might have helped me become a better software engineer in any object-oriented language. I’ll keep it handy as a constant reference and look forward to reading it again more carefully.”
From the Back Cover
"Next time some kid shows up at my door asking for a code review, this is the book that I am going to throw at him." -Aaron Hillegass, founder of Big Nerd Ranch, Inc., and author of "Cocoa Programming for Mac OS X" Unlocking the Secrets of Cocoa and Its Object-Oriented Frameworks Mac and iPhone developers are often overwhelmed by the breadth and sophistication of the Cocoa frameworks. Although Cocoa is indeed huge, once you understand the object-oriented patterns it uses, you'll find it remarkably elegant, consistent, and simple. "Cocoa Design Patterns" begins with the mother of all patterns: the Model-View-Controller (MVC) pattern, which is central to all Mac and iPhone development. Encouraged, and in some cases "enforced" by Apple's tools, it's important to have a firm grasp of MVC right from the start. The book's midsection is a catalog of the essential design patterns you'll encounter in Cocoa, including
- Fundamental patterns, such as enumerators, accessors, and two-stage creation
- Patterns that empower, such as singleton, delegates, and the responder chain
- Patterns that hide complexity, including bundles, class clusters, proxies and forwarding, and controllers
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
In most subjects we learn by acquiring a little bit of knowledge and, once that bit has been understood, we move on to the next little bit, until the bigger topic is understood. First we learn A then we learn B. Unfortunately, this method of learning does not work well with application frameworks such as Cocoa. These frameworks usually consist of a number of complex idea that are strongly interrelated. You cannot learn A then B, since A requires B and B requires A. Instead you must learn topics A..Z all at the same time! Cocoa is especially difficult for most programmers since it is based on using Objective C, and Objective C is based on Smalltalk. Smalltalk is an extremely dynamic language whose principles are significantly different than those of current popular languages. Thus, most programmers must learn zilllions of elements of the Cocoa framework and also the unusual ideas behind Objective C (Smalltalk). These are essential since Cocoa works differently than other popular frameworks and cannot be understood without understanding Objective C's dynamic approach to programming.
Up until now we have had Objective C books which help learning Objective C, and the excellent Hillegass book (Cocoa Programming for Mac OS X) which is a tutorial on Cocoa. The Hillegass book does help the reader understand many principals behind Cocoa, but it stops short of giving in depth knowledge of the design patterns that Cocoa uses. Thus when the user tries to go beyond the Hillegass book he/she is frustrated because they were not taught the full idea behind each element of Cocoa and their connections to other elements. There is not enough information for the reader to branch out to develop their own programs.
Cocoa Design Patters, on the other hand, presents, in a very professional manner, the most important Cocoa patterns, in depth, and how they are all inter-related. Furthermore, it presents details how how to use the patterns, examples of where they are used in Cocoa, and includes extremely valuable and unbiased information on the pro's and con's and pitfalls of using each pattern. Although this is certainly not tutorial/beginner information, the book is extremely well written and enjoyable to read (especially for those of us who loved Smalltalk and other dynamic languages). It is one of the best written highly technical books I have ever read (and I have been programming since 1970).
In my opinion this book will save the prospective Cocoa programmer many, many, many hours of frustration. I only wish it had been available several years ago when I first tried to learn Cocoa (I did not succeed then, but I am succeeding now).
One final note. The authors could do the Mac Developer Community, and the wider developer community, an enormous favor. In this book they demonstrate an impressive depth of knowledge about Cocoa, Objective C, the Mac development world, and the XCode tools. It would be fabulous if they were to develop a professional unbiased critique and comparison of the pro's and con's of the Objective-C/Cocoa approach to development with other framework/development environments (e.g. Microsoft's). I think this is especially important since the dynamic language approach to programming has fallen out of favor, yet I think it has many benefits that are seriously under appreciated. This document would:
Clearly show programmers the benefits of the dynamic language / Cocoa approach to programming. Perhaps it would reawaken interest in dynamic languages!
Point out the areas where Objective C/Cocoa/XCode has weakness and should be improved. This may inspire Apple to improve their development tools at a brisker pace.'
The development world has had few breakthrough improvements over the last decade or two. I think that much can be learned from Cocoa/Objective C, and I hope That Cocoa Design Patters is just the beginning of a renewal of interest in this too-long-neglected approach to software development.
The book is worth reading even if you do not (exclusively) program for the Mac. The 'design patterns' in the title are more than just a 'higher-level coding standard' for the Mac. They are actually design philosophies, ways of structuring your code. Yes, they heavily utilise the dynamic nature of Objective-C but it does not mean that their relevance is restricted to that environment. Objective-C is a fairly thin layer and a small runtime on top of C, after all.
Each design pattern described in the book is a solution methodology for a software engineering problem. The authors present a problem, usually through a small example. Then they explain the 'design pattern', the solution chosen by the Cocoa developers. They then show you why that particular way of approaching the problem makes the result more robust, more flexible and easier to modify. Software reusability and maintainability are central tenets of the book. They demonstrate that while a quick-and-dirty solution might be shorter, using the given design pattern, or, if you like, adhering to a particular software development principle will save you development and maintenance time in the long run, especially for large projects.
Many of the design patterns revolve around the factoring your problem into preferably orthogonal subproblems, decompose your software into units mapped to the subproblems and the design of the interactions between those units. The book is all about minimising inter-dependencies, by keeping your interfaces clean and your units being self-contained. The design patterns are methods to achieve that goal. Whether you rely on the objects and the dynamic features of Objective-C or you achieve the same result by explicit bits of procedural code is beside the point.
You have to know at least some Objective-C and introductory level of Cocoa to be able to read the book, as all examples use those. However, what you learn from the book you can use in any software project, regardless of language and environment. If you know enough Mac-speak so that you can read the book, I recommend it, even if you are not doing any serious Mac development.
The style of the book is pleasant, the explanations are concise but they are clear and thorough. The examples are also good, they are large enough to show the practical benefit of the design pattern they demonstrate but are small enough to the reader actually reading the code and not just glazing over the listings.
Most recent customer reviews
Same matters are: Category, Notification, Delegates, Outlets, Target, Action, Proxies...Read more