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.

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.

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.

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.

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.

I have only read half way through the book and my understanding of coding theories has grown so much. The chapters in the book really break down the importance of design patterns, and even patterns you thought would be useless or complex are brought into light. More than just code the theory of coding structure is what really inspires me. I highly recommend this book especially to those that work in a team environment. You can not go wrong with this one. Hats off to Joey and Danny.

This is quite good. Actually, as far as design patterns applied to ActionScript with Object-Oriented principals go, this is the bomb.

It's nice to see a design pattern book written using ActionScript as the targeted language. No more reading books targeted for C++, C#, or Java, and try to apply them to AS2. This is especially meanful to cases where ActionScript has no equivalent syntax.

While the book is targeted for AS3, it is equally applicable to AS2. The principals are the same.

It's also nice to finally pick up a book that calls itself "Advanced ActionScript" that indeed talks about advanced topics. Highly, highly recommended.

This is definitely a must-read for anyone who is venturing into Flash/Flex applications, or is serious about becoming a full-time Flash Platform RIA developer.

This book is slim and, I feel, quite perfect in that I never felt overwhelmed by any chapter and never saw a hint of fluff. I really enjoy these direct topics.

The design patterns movement, the beginnings of which can be traced to Gamma, Helm, Johnson and Vlissides famous Design Patterns book, has informed and changed software development, and spawned a raft of books and study groups.

That's right, people actually get together, read these books one chapter at a time, and talk about software design patterns - for fun! (I admit to being one of them). So, Joey Lott and Danny Patterson are taking on a real challenge in writing a book on this topic, and the term "advanced" in the title is well-advised.

The first chapter is not about patterns but pretty basic object oriented stuff: inheritance vs. composition, polymorphism, code conventions, design first then write unit tests first. These topics are standard fare for a book of this type, and the chapter is blessedly succinct.

The second chapter is on programming to interfaces, a fundamental idea of great importance. Lott and Patterson give one of the clearest explanations I have read of the advantages, and give a convincing argument for always programming to interfaces even when you are using inheritance. Dude! Actionscript3 has interfaces!

Then you get the chapters on patterns: Model/View/Controller, Singleton, Factory/Template, Proxy, Iterator, Composite, Decorator, Command, Memento, and State. I guarantee that after you have read these chapters and studied the code, you will understand these patterns a lot better than before, and will have ideas on how to use them.

The book is rounded out with entire chapters on Events (everything you always wanted to know but were afraid you wouldn't understand why), sending and loading data, E4X, and RegEx.

I have only a couple of minor cavils about the book. It would have been SO EASY to include the compilation command line.

/flex_sdk_2/bin/mxmlc MyProgram.as

See? Now you can compile for free! The book doesn't give you info on command line tools, but assumes you have downloaded and installed the 30-day flex compiler. And in the wonderfully worked out and fully crafted source code which you can download from the publisher's website, once again I was left scratching my head, when it said you have to set the source path to the library. Thanks very much, but tell me how?

It is not possible to have a useful book of this type without showing substantial amount of source for real projects, and fortunately, here Lott and Patterson really deliver. The projects are not on the level of usefulness of Phillip Kerman's book on Flash 8 at work, but they are complete enough to illustrate the patterns. All source is in 100 percent Actionscript 3, with no Flex component source; since the book is not about Flex I consider this to be an advantage. At any rate, this book communicates the usefulness, as well as the nuts and bolts, of some fundamental software design patterns, several of which I have already used, and others which I will use soon.

This book definitely will help programmers w/ OO background to quickly pickup design patterns in Action Script 3.0. I've applied a few of them successfully in my current Flex 2 project.

This takes you a step further in your knowledge of ActionScript 3.0 OOP. The book is easy to follow and answers substantial questions with detail.

I picked this book up to have something to read during my Christmas vacation and read it front to back in one week. This is definitely one of the better ActionScript books out there.

First off, if you don't already understand basic object-oriented concepts such as polymorphism, encapsulation, how and why to build a class, etc., then this book isn't for you. I recommend starting with either 'Essential ActionScript 2.0' or 'Object-Oriented ActionScript for Flash 8' and getting comfortable with object-oriented development before moving on to this book.

Having said that, this book is great for advanced users. A lot of the design patterns and concepts were review for me, however there's a good chance there are at least a few design patterns that you aren't already familiar with in this book. I also really like the fact that this book emphasizes composition over inheritance; that's a concept that a lot of books don't stress properly. Also noteworthy is their emphasis on programming to interfaces, except when an abstract class is more applicable. The examples in this book are all written in ActionScript 3.0, however the concepts taught apply to ActionScript 2.0 as well, so even if you aren't ready to learn ActionScript 3.0, this is still a great read.

I did find quite a few mistakes in this book, mostly class names and constructors not matching up, or refrences to a class in text, then the example using a different class name. If you are smart enough to be reading an advanced book like this, then the mistakes should be easily caught and not confuse you at all.

Overall, the guys from Schematic delivered a great book. There is plenty of great material inside, even for the advanced reader. Highly recommended.

This is a book that I would classify as a "should have" for any Flash/Flex developer that uses ActionScript 3 and for whom OOD/OOP is important. If you could care less about incorporating OOD/OOP into your web applications, then you can pass on this one.

There is, in my opinion, a major shortcoming in this book. In presenting the MVC (Model, View, Controller), the "View" classes are presented as classes that extend the Sprite class, in which the author draws the objects via ActionScript. Unfortunately, the author seems to ignore the fact that most developers, who employ Flex to build their web apps, will use MXML to layout the view. In such cases, there are no examples of how the author would design the view and controller classes so as to follow a proper MVC design pattern. The same would be true for Flash developers as most are not going to draw the entire screen of their web apps via ActionScript. As a consequence, I feel that most people who read this book will not successfully implement these design patterns into their Flex web apps unless they have prior OOD/OOP experience. In either case (with or without OOD/OOP experience), only the most determined web developers will be able to translate the design patterns of this book in a meaningful way within their applications. This above-mentioned shortcoming is carried throughout the book.

While I realize the title of the book is "Advanced ActionScript 3...", and the argument can be made that the content was only meant to address pure ActionScript 3 concepts, it still ignores the fact that most developers will not develop their web applications with "only" ActionScript 3 and absent any MXML document to define their screen layout. As such, this becomes all but useless in promoting the increase use of the design patterns being presented.

Ron