Advanced ActionScript 3 with Design Patterns (Paperback)

by Joey Lott (Author), Danny Patterson (Author)
Key Phrases: template method, abstract method, public function reset, Flash Player, Flash Remoting, Factory Method (more...)

Editorial Reviews

Product Description
Today's ActionScript-based applications require increasingly sophisticated architectures and code. This book aids intermediate and advanced ActionScript developers in  learning how to plan and build applications more effectively. You'll learn how to apply design patterns as solutions to common programming scenarios. Beyond a reference, Advanced ActionScript with Design Patterns is a practical guide complete with sample mini-applications illustrating each design pattern.

Table of Contents:

Part I - Successful Projects
1. How to Design Applications
   
2. Programming to Interfaces
   
Part II - Patterns

3. MVC
   
4. Singleton
   
5. Factory (Abstract Factory and Factory Method)
   
6. Proxy
   
7. Iterator
   
8. Composite
   
9. Decorator
   
10. Command
   
11. Memento
   
12. State
   
Part III - Advanced ActionScript Topics

13. Working with Events
   
14. Sending and Loading Data
   
15. E4X (XML)
   
16. Regular Expressions




About the Author
Joey Lott works with ActionScript during the day and by night he's a super-secret international man of mystery, rescuing animals and children from harms way, righting wrongs, and working for global peace, the rights of all living beings, and environmental responsibility. Joey is the author (or co-author) of a veritable arsenal of ActionScript and Flash-related titles, including the ActionScript Cookbook, Programming Flash Communication Server, and the Flash 8 Cookbook. In his free time he likes to write poetry, pursue competitive origami, and train in the art of aikido. Danny Patterson is a Consultant specializing in Flash and Web technologies. He also works with Schematic as a Senior Flash Architect. He is an Adobe Community Expert and has contributed over 40 articles to Community MX and the MX Developers Journal. He is also the co-author of the Flash 8 ActionScript: Training from the Source book by Adobe Press. He has spoken at many conferences and user groups including Flash in the Can and Flash Belt. Danny is certified in both Flash and ColdFusion and has worked on web projects for many large companies including Microsoft, IBM, Dell, Adobe and Starz. You can check out his blog at DannyPatterson.com.

Product Details

• Paperback: 304 pages
• Publisher: Adobe Press; 1 edition (November 12, 2006)
• Language: English
• ISBN-10: 0321426568
• ISBN-13: 978-0321426567
• Product Dimensions: 9.2 x 7.9 x 1.7 inches
• Shipping Weight: 3.2 pounds (View shipping rates and policies)
• Average Customer Review: 4.7 out of 5 stars See all reviews (25 customer reviews)
• Amazon.com Sales Rank: #34,746 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

58 of 70 people found the following review helpful:

3.0 out of 5 stars Recommended, but..., December 27, 2006

By	R. Grimes (Sandy, Utah USA) - See all my reviews (REAL NAME)

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

26 of 30 people found the following review helpful:

5.0 out of 5 stars The real deal, March 19, 2007

By	George D. Girton (Los Angeles, CA USA) - See all my reviews (REAL NAME)

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.

7 of 8 people found the following review helpful:

5.0 out of 5 stars Perfect balance of concepts and AS3 specific idioms, August 27, 2007

By	Lawrence Maccherone Jr. "WS Expert" (Pittsburgh, PA) - See all my reviews (REAL NAME)

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.