Product Description

“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

And that’s not all of them! Cocoa Design Patterns painstakingly isolates 28 design patterns, accompanied with real-world examples and sample code you can apply to your applications today. The book wraps up with coverage of Core Data models, AppKit views, and a chapter on Bindings and Controllers.

 

Cocoa Design Patterns clearly defines the problems each pattern solves with a foundation in Objective-C and the Cocoa frameworks and can be used by any Mac or iPhone developer.

---

Product Details

• Amazon Sales Rank: #20965 in Books
• Published on: 2009-09-11
• Original language: English
• Number of items: 1
• Binding: Paperback
• 456 pages

Features

• ISBN13: 9780321535023
• Condition: NEW
• Notes: Brand New from Publisher. No Remainder Mark.
• Click here to view our Condition Guide and Shipping Prices

Review

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.”

–Eoin Houlihan

 

“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.”

–Daryl Spitzer

About the Author

Erik M. Buck founded EMB & Associates, Inc. in 1993 and built the company into a leader in the aerospace and entertainment software industries by leveraging the NeXT/Apple software technology that would later become Apple’s Cocoa frameworks. Mr. Buck has also worked in construction, taught science to 8th graders, exhibited oil on canvas portraits, and developed alternative fuel vehicles. Mr. Buck sold his company in 2002 and currently holds the title of Senior Staff at Northrop Grumman Corporation. Mr. Buck received a B.S. degree in computer science from the University of Dayton in 1991 and is a frequent contributor to Cocoa mailing lists and technical forums.

 

Donald A. Yacktman has been using Cocoa and its predecessor technologies, OpenStep and NextStep, professionally since 1991. He coauthored the book Cocoa Programming and has contributed to the Stepwise website as both author and editor. He has worked for Verio/iServer and illumineX in the past. At present he works as an independent consultant assisting in the design and implementation of Cocoa and iPhone applications. Mr.Yacktman received B.S. and M.S. degrees in electrical and computer engineering from Brigham Young University in 1991 and 1994, respectively.

 

 

Excerpt. © Reprinted by permission. All rights reserved.

Preface

Much of the technology embodied by Apple's Cocoa software has been in commercial use since 1988, and in spite of that maturity, Cocoa is still revolutionary. The technology has been marketed with a variety of names including NEXTSTEP, OPENSTEP, Rhapsody, and Yellow Box. It consists of a collection of reusable software frameworks that contain objects and related resources for building Mac OS X desktop and mobile applications. In recent years, Apple has expanded Cocoa dramatically and added new software developer tools to increase programmer productivity beyond the already famously high levels Cocoa already provided.

Programmers are often overwhelmed by the breadth and sophistication of Cocoa when they first start using the frameworks. Cocoa encompasses a huge set of features, but it's also elegant in its consistency. That consistency results from the application of patterns throughout Cocoa's design. Understanding the patterns enables the most effective use of the frameworks and serves as a guide for writing your own applications.

This book explains the object-oriented design patterns found in Apple's Cocoa frameworks. Design patterns aren't unique to Cocoa; they're recognized in many reusable software libraries and available in any software development environment. Design patterns identify recurring software problems and best practices for solving them. The primary goal of this book is to supply insight into the design and rationale of Cocoa, but with that insight, you'll be able to effectively reuse the tried and true patterns in your own software—even if you aren't using Cocoa.

What Is a Design Pattern?

Design patterns describe high quality practical solutions to recurring programming problems. Design patterns don't require amazing programming tricks. They're a toolbox of reusable solutions and best practices that have been refined over many years into a succinct format. They provide a vocabulary, or shorthand, that programmers can use when explaining complex software to each other. Design patterns don't describe specific algorithms or data structures like linked lists or variable length arrays, which are traditionally implemented in individual classes. The design patterns in this book don't describe specific designs for applications even though examples are provided. What the patterns do provide is a coherent map that leads you through the design of Cocoa itself. Patterns show how and why some of the best and most reusable software ever created was designed the way it was.

At a minimum, design patterns contain four essential elements:

• The pattern name
• A brief description of the motivation for the pattern or the problem solved by the pattern
• A detailed description of the pattern and examples in Cocoa
• The consequences of using the pattern

Parts II, III, and IV of this book contain a catalog of design patterns. Each chapter in the pattern catalog introduces a design pattern and provides the essential information you need to recognize and reuse the pattern.

The pattern's name helps developers communicate efficiently. A shared vocabulary of pattern names is invaluable when explaining a system to colleagues or writing design documentation. Named patterns clarify thought, and the implications of a design—even the rationale behind a design—can be communicated with just a few words. Programmers familiar with patterns immediately infer the uses and limitations of objects composing a named pattern as well as the overall design employed and the consequences of that design.

Apple's own documentation occasionally uses design pattern names in both class references and programmer's guides, but the documentation doesn't always explain what the patterns are or what they should mean to a developer. In addition, Apple frequently uses their own names for design patterns instead of the terms commonly used throughout the industry. In some cases, the differences in terminology are the result of simultaneous independent discovery. In other cases, the patterns were first recognized in Cocoa or its predecessor NEXTSTEP, and it's the industry that changed the name. The patterns described in this book are identified using both Apple's terminology and the common industry names when applicable so you can see the correlation.

Each design pattern includes a description of the problem(s) and motivation for applying the pattern. Some patterns include a list of problem indicators that suggest the use of the pattern. Because Cocoa contains many patterns that are applicable in diverse situations, the patterns have been carefully organized so that the same problems in different contexts are readily identified. In some cases, related patterns that should be avoided are also identified.

Finally, each pattern identifies the consequences that naturally result from its use. The consequences and trade-offs of design alternatives are crucial when evaluating which patterns to use in a particular situation.

Why Focus on Design Patterns?

When approaching a software technology as vast as Cocoa, it's easy to lose sight of the overall architecture and rationale of the technology. Many programmers comment that they feel lost in the multitude of classes, functions, and data structures that Cocoa provides. They can't see the forest because they're concentrating too much on individual trees. The patterns used in Cocoa provide a structure and organization that helps programmers find their way. The patterns show programmers how to reuse groups of cooperating classes even when the relationships between the classes are not fully explained in the documentation for individual classes.

The goal of object-oriented programming is to maximize programmer productivity by reducing lifetime software development and maintenance costs. The principal technique used to achieve the goal is object reuse. An object that is reused saves the programmer time because the object would otherwise need to be reimplemented for each new project. Another benefit of reusing objects is that when new features are required or bugs are identified, you only need to make changes to a small number of objects, and those changes benefit other projects that rely on the same objects. Most importantly, by reusing objects, fewer total lines of code are written to solve each new problem, and that means there are fewer lines of code to maintain as well.

Design patterns identify successful strategies for achieving reuse on a larger scale than individual objects. The patterns themselves and all of the objects involved in the patterns are proven and have been reused many times. The consistent use of design patterns within Cocoa contributes to the high level of productivity that Cocoa programmers enjoy. Design patterns advance the art of object-oriented programming.

The patterns within Cocoa provide a guide for designing many different types of applications. Cocoa contains some of the most famously well-designed software ever produced, and following the patterns used by Cocoa will make you a better programmer even when you aren't using Cocoa.

This book should satisfy your intellectual curiosity. Design patterns answer "why" as well as "what" and "how." Knowing how patterns are applied and more importantly why patterns contribute so much to productivity makes the daily job of programming more enjoyable.

Guiding Principles of Design

All of the design patterns described in this book have several properties in common. In each case, the goal of the pattern is to solve a problem in a general, reusable way. Several guiding principles of design help ensure that the patterns are flexible and applicable in many contexts. The same strategies that are applied to design of individual objects are applied to design patterns as well. In fact, patterns that involve many objects benefit even more from good object-oriented design than simpler systems. One reason that patterns exist is to help make sure that productivity gained from reusing the patterns exceeds the productivity gained from using individual objects—the sum is greater than the parts.

Minimize Coupling

As a general design goal, coupling between classes should be minimized. Coupling refers to dependencies between objects. Whenever such dependencies exist, they reduce opportunities for reusing the objects independently. Coupling also applies to subsystems within large systems of objects. It's important to look for designs that avoid coupling whenever possible.

All of the Cocoa design patterns exist in part to limit or avoid coupling. For example, the overarching Model-View-Controller (MVC) pattern described in Part I of this book, "One Pattern to Rule Them All," is used throughout Cocoa to organize subsystems of classes and is applied to the design of entire applications. The primary intent of the MVC pattern is to partition a complex system of objects into three major subsystems and minimize coupling between the subsystems.

Design for Change

It's important to use designs that accommodate changes through the lifecycle of a software system. Designs that are too inflexible ultimately restrict opportunities for reuse. In the worst case, no reuse occurs because it's easier to redesign and reimplement a system than it is to make changes within an existing rigid design.

It's possible to anticipate certain types of changes and accommodate them in a design. For example, the Cocoa Delegates pattern provides a mechanism for one object to modify and control the behavior of another...

---

Customer Reviews

If Cocoa is Your Thing, This Book is Essential
It was the iPhone that finally brought me into the world of Cocoa programming. I quickly fell in love with the Cocoa & Cocoa Touch frameworks, finding them to be elegant, consistent and truly useful. I've read several books on Cocoa, Objective-C and Mac / iPhone development, but this one stands alone in its quest to fill the gaps, to cement a deep and thorough understanding of one of the best frameworks ever written.

Simply stated, this book is a joy to read. It answered many questions that I had about the "why" behind the evolution of Cocoa and has left me feeling better able to make the most of its power. Cocoa Design Patterns is written in a style that is extremely accessible. It is almost like a detective novel as each chapter unravels the secrets of Cocoa. The most fun I've had reading a technical book in a long while.

Unlocking Cocoa Programming
This superb book has finally unlocked Cocoa programming! Let me explain.

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.

Develops a good foundational understanding
This book is not for beginners to Cocoa. I would only recommend it folks that have a reasonable amount of experience with Cocoa / Objective-C. Don't take this the wrong way; I'm only defining the target audience. This book details the patterns at work in Cocoa's architecture. While this text may confuse those new to Obj-C or Cocoa, it provides valuable insight into Cocoa usage patterns.

Cocoa Design Patterns explains techniques commonly used throughout the Cocoa architecture (Model-View-Controller, Release/Retain Counting, Delegates, etc.), and provides concrete implementation examples in the frameworks. For each pattern it also describes the scenario that you may use it in, and the consequences, good and bad, to using the pattern. I would recommend this book to anyone after they've cut their teeth on Cocoa, after writing their first couple simple applications. This book shines light on some of the design decisions Apple made with Cocoa, and helps the reader understand how to best leverage the patterns utilized in the Cocoa frameworks.