Customer Reviews

Advanced ActionScript 3 with Design Patterns

5 star:		(18)
4 star:		(6)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

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

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.

This book presents may interesting design approaches for OOP programming.

Two pitfalls - too many typos (including throughout the code excerpts), and not enough examples. The novice or intermediate programmer may not be able to debug the code printed in the book.

Otherwise, this book is good for programmers looking for more flexibility and fresh approaches for their code.

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

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

ActionScript does not really support most of the design patterns in this book. That's not the fault of the authors, just the nature of ActionScript.

However, the writing is not all that straightforward either. There is some wordiness and some of the attempts at explaining things are unnecessarily awkward. One particularly annoying characteristic is the authors' habit of getting off the subject in mid-paragraph to cover some rare exception to an example they have presented - an exception that doesn't have any bearing on the topic at hand. For example, when discussing the subject of interfaces, the authors mention an example of an interface used by two different classes provided by Adobe for networking (I think). The authors break off momentarily into covering the possible values or types that could be provided for parameters in the interface - when this has nothing to do with the subject of interfaces themselves. One second we're reading about interfaces, the next it's something about RTMP or RFMP, or whatever networking term - related to a networking application of the example interface, but completely unnecessary for understanding interfaces themselves. (Also, never really got a good reason for using formalized interfaces out of the book, either - though the authors seem to like them a lot.)

With regard to the whole subject of design patterns in ActionScript, this book left me with the distinct impression that design patterns, for most ActionScript projects, simply add completely unnecessary complexity and overhead to the programming process. However, I work on projects alone, so maybe this stuff has greater application in a collaborative environment.