Advanced ActionScript 3 with Design Patterns

by Danny Patterson and Joey Lott

Book Overview

Flash-based applications have increased in both size and scope, leaving developers searching for flexible and scalable applications. ActionsScript provides the capability of developing patterns, and... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0321426568
• ISBN13: 9780321426567
• Release Date: January 2006
• Publisher: Adobe Press
• Length: 286 Pages
• Weight: 1.10 lbs.
• Dimensions: 0.6" x 7.4" x 9.1"

Customer Reviews

excellent concise info on AS3

I realize the book title (and the focus and organization) is about design patterns, but I thought it was worth adding the fact that--for me at least--it's the one book I keep coming back to for great lucent coverage of really key AS3 concepts including event dispatching (and using IEventDispatcher instead). I mean, Colin's Essential AS3 is one to turn to for definitive answers on sub-atomic (and important) details... but I still keep coming back to Danny and Joey's book because it's so direct and to the point. To really learn a subject you need more than a book--but to go back over things... to get a good skeleton starter script (which doesn't have extra baggage)... and for brief clear explanations, this book really does it. It's by no means a dated book either. I just think some people might pass over this book because the title makes it sound like it just covers design patterns when, in fact, it's just a great AS3 book.

Great Book!

Although written specifically for ActionScript this book really helped me further my understanding of design patterns and how to apply them to all my software development projects. Additionally, the the last few chapters cover some advanced ActionScript topics like E4X. Recommended for any experienced developer interested in design patterns.

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 thi

The real deal

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.

One of the best ActionScript books out there....

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.