Others say...

"Perfect balance of concepts and AS3 specific idioms"
This book is clearly written by authors who "think in ActionScript 3" and it's written at the perfect level for folks who already understand design patterns but want some guidance on how they apply (or don't) in AS3.

If you are looking for an introduction to Design Patterns, this book does a decent job of that but it generally assumes you have a bit of understanding in that regard. The HeadFirst book (java) walks you through application evolution which really makes the case for why the patterns are useful. The HeadFirst book also includes exercises that really make the concepts sink in and teach you to recognize when each pattern applies. However, the head first book is very much a java book. Similarly, the original design patterns book by the Gang of Four (GoF) is about design patterns in C++.

This book, however is written clearly from the perspective of an ActionScript 3 (AS3) programmer. In some core ways, AS3 is very different than Java and even more so with respect to C++. The event model is baked into the language and asynchronous programming is a different style. Also, XML and XPath are native constructs in ActionScript 3, not libraries like they are in other languages. These differences (among others) imply that some of the original GoF and Java patterns manifest themselves differently and some patterns don't apply at all. This book doesn't merely take the Java or C++ idioms and make them run under ActionScript 3. They've totally re-thought them and presented the ones that are appropriate for AS3 in a way that is probably ideal for AS3. They've also left out or provided alternatives for the traditional ones that are not appropriate considering the language differences. For instance, the observer pattern is one of the core GoF and HeadFirst patterns. However, it doesn't show up in this book. Instead, there is a chapter on "WORKING WITH EVENTS" which is the native AS3 construct that essentially takes the place of the observer pattern. In contrast, the O'reilly book happily shows you an AS3 translation of the GoF/HeadFirst observer pattern and never tells you to use the built-in event structure instead.

Not only do the authors demonstrate their "thinking in AS3" at the level of design patterns but their code examples include lots of little AS3 specific idioms. AS3 still shows it's dynamic language roots in subtle ways and these authors play to that strength. For instance, a dynamic class inherited from the Proxy class includes a method called, getProperty(). In chapter 4, they override this method and use it in combination with E4X (the native XML capability), to provides an elegant way to build a generic application settings framework that you can use in any application without modification. If your XML settings file changes, the class will appear to magically change its interface. The chapter is about the Singleton pattern but I learned about dynamic/Proxy/getProperty() and E4X idioms as a side benefit.

If I had one complaint about this book, it's a minor one and it's a complaint that I also make about the Java language and I'm now starting to regularly make about Adobe's recommendations with respect to AS3 class interfaces. Like C# and Python and other more recent languages, AS3 has a construct for turning public property references into get/set function calls without changing the calling code. This book shows you that style of coding as well as the Java recommended getSomeProperty/setSomeProperty style but it recommends that you never use public properties in your class interfaces. In my mind, the main advantage to having the get/set function language feature is that you can start out with public properties and later change them to accessors methods without breaking the calling code. The reason we don't recommend that you have public properties in java is that there is no language feature that allows you to later add accessor methods without breaking the calling code. In Java, the lessor of two evils is to have you always create them up front. I see no reason to live with the same evil in AS3. However, this is minor nit and now that you've read my explanation here, you can ignore the recommendation. :)

I highly recommend this book. If you have the least bit of experience with design patterns and are now coding in AS3, just get this book. If you are totally new to the concept of design patterns, then you may want to get the HeadFirst book AND this book.

"Excellent, but a few quibbles"
Not to rehash the many other good reviews, I'll keep this short. This is an excellent book that opened my eyes in many ways; I am a beginning OOP programmer with quite a bit of procedural experience. This book is a great bridge.

However, do beware the code typos: there are a lot of them and it can slow comprehension. It knocked this down from 5 to 4 stars for me; simply compiling and running the code would have caught most of these and I find it sloppy.

Also, in my newbie opinion, this book talks the talk but does not walk the walk when it comes to advocating composition over inheritance. It says to favor composition, but in many of the examples, perhaps to make them shorter, extension is used instead. For example, I think a complex object should almost always *contain* its graphic component-- sprite or movieclip-- not extend and therefore *be* a graphic component. But maybe I am, in my newbieness, too doctrinaire on this point.

"Great for migration to AS3 and into using DesignPatterns"
This is well written. It appeals to more than one need. If I could I would down grade the rating to 3 stars after I got deeper into doing examples and dealing with the and incorrect and missing files at the download site. See details below.

For those who are Actionscript OO programmers that want to get into the Design Patterns the first two chapters will lead you there quickly. However you will want to read them again after experimenting with the design patters presented in chapters 3 - 12. At least a lot more clicked for me doing it that way. I actually compiled all the examples for the many chapters I read (and hand typed some for experience) using the mxmlc compiler. So you can do these without Flash CS3 if you must.

The design patterns presented in chapters 3-12 all have very useful Actionscript examples using AS3. So you can apply the examples to your projects. As well you will see how new functionality of AS3 is applied. For example it uses regular expressions in the decorator pattern FileReader example.

The final section of the book Chapter 13-16 show new important changes to using Actionscript 3 th at you need to unlearn from AS2 such as Events, Data Communications, the new EX4 for XML and regular expressions.

Digital files unfortunately at author's site are not perfect. Also I found a few minor typos such as DecoratorExample2 as the constructor to the DecoratorExample class. As well as incorrect files where the Decorator FileReader example files were repeated for the Decorator Example Shapes.

There are also a few code typos in the text. Minor but still. Such as page 121 the class should import and extend AbstractReaderDecorator but the code was printed as ReaderDecorator. Another example is page 147. There is an undefined variable _object.

Another problem is chapter 10 download files are not all provided at the download site. The first 1/2 of chapter is reasonably explained but the game example is extensive, weakly explained and NO DOWNLOAD FILES. Only the brave could follow it.

It looks the author was cleaning up code for the excellent presentation and missed a few in editing. Copy and paste of code might have prevented that. A coder with experience in debugging can spot and correct these quickly.

Peachpit makes it a mystery for feedback to get errata input and digital files corrections. Correct that Peachpit and improve quality using your readers as free input!

Despite the few typos and digital file errors, the book is currently (June 2007) the only choice for those wanting a fast track from AS2 and into AS3 with patterns.

"Build flexible and adaptive applications"
Building websites and web animations with Adobe Flash and ActionScript is only the tip of the iceberg when it comes to what you can create with the Flash and ActionScript combination. When you are working on a complex project such as a desktop application, you need to consider design and architecture. This book by Joey Lott and Danny Patterson will take you through the steps for building a flexible and adaptive application. As you can tell from the topic, the reader needs to be an advanced user who has a solid background in programming and experience with object-oriented ActionScript.

The book begins with an introduction to application design principles and follows with a discussion of the most proven design patterns for building flexible and adaptive applications. First, the authors discuss Polymorphism and how important programming to an interface is to application design. Next, the authors use an example project to teach the Model View Controller pattern. The sample project is an analog and digital clock model which demonstrates how changing the model from analog to digital does not affect the application due to the flexibility of the design. The next pattern the authors discuss is the Singleton design pattern that can be used to limit a class to one global instance, such as the state of the mouse cursor.

One task that many applications need to perform is to access a remote resource such as an external image file or to use an object that is not immediately available. The authors discuss the two most common proxy patterns used for this situation; Remote and Virtual. The two sample projects they use are an image loader and search proxy. Another common task is dealing with a collection of data and the authors discuss the Iterator pattern which can read data without endangering the data structure. Another frequent task is to deal with hierarchical data such as a file system. The authors use a file and directory system as a sample project to demonstrate how to use the Composite pattern. Many times, Flash applications are based on reusable components and the authors discuss how to use the Command and Memento patterns to build a sample game. They round out the book with a few advanced ActionScript topics such as events, sending and loading data, E4X and regular expressions.

Joey Lott is an author of several books and Senior Software Architect at Schematic. Danny Patterson is an author of several books and articles. He is a Senior Flash Architect at Schematic and a Flash/Flex consultant.

"Simple implementation examples for the OO minded developer"
If you are familiar with Object Oriented programming, this book will show you how to implement design patterns in Actionscript 3. The examples are clear and concise.

I highly recommend you have at least a moderate skill level with Actionscript 3 before approaching this book, however- if you can't skim the code and understand it without having to look up the functions they are using, then it will be a frustrating read.