ActionScript 3.0 is now released, but the author is yet to update his classic book on the subject of ActionScript for this new version. Thus, I still highly recommend this book, since it covers ground not found in other books on the subject and I find it to be an outstanding tutorial on object-oriented programming as well as a precise tutorial on ActionScript. Keep in mind, though, that the author's version of this book for ActionScript 3.0 is due out in June 2007. So, if you don't need to know this material before next summer, you might want to wait on your purchase. I review this book in the context of its table of contents.

Part I: The ActionScript Language
Chapter 1. ActionScript 2.0 Overview
Starts with a quick summary of ActionScript 2.0's core features and Flash Player 7's new capabilities. If you have an ActionScript 1.0 background, the summary will give you a general sense of what's changed in the language. If, on the other hand, you're completely new to Flash or to ActionScript, you may want to skip directly to Chapter 2.

Chapter 2. Object-Oriented ActionScript
Ironically, Flash users who are new to object-oriented programming (OOP) are often familiar with many object-oriented concepts without knowing their formal names. This chapter demystifies some of the terminology and brings newer programmers up to speed on key OOP concepts. It also serves as a high-level overview of OOP in ActionScript for experienced programmers who are making their first foray into Flash development.

Chapter 3. Datatypes and Type Checking
ActionScript 2.0 defines a wide variety of datatypes. Some datatypes are native to the language itself (e.g., String, Number, and Boolean). Others are included in the Flash Player and are available throughout all Flash movies (e.g., Color, Date, and TextField). Still other datatypes are defined by components that can be added individually to Flash movies (e.g., List, RadioButton, and ScrollPane). This chapter covers all of that.

Chapter 4. Classes
This chapter covers the syntax and theory behind classes in ActionScript 2.0 and assumes a prior basic understanding of the concepts discussed in Chapter 2. Classes are the foundational structure of all object-oriented programs, making them arguably the most important aspect of OOP. As such, classes are predictably intricate. This chapter is correspondingly lengthy and detailed but, even so, newer programmers can use it to learn the basics of creating and using classes.

Chapter 5. Authoring an ActionScript 2.0 Class
Chapter 4 covered the general anatomy of ActionScript 2.0 classes. In this chapter that theory is put into practice by authoring a real-world ActionScript 2.0 class named ImageViewer. The ImageViewer class creates an on-screen rectangular region for displaying a loaded JPEG image. The chapter covers designing and coding the class itself, as well as using it in a Flash document.

Chapter 6. Inheritance
In OOP, inheritance is a formal relationship between two or more classes, wherein one class borrows (or inherits) the property and method definitions of another class. In the practical, technical sense, inheritance simply lets one class make use of the code in another class. This chapter covers the theory of inheritance as practiced in ActionScript.

Chapter 7. Authoring an ActionScript 2.0 Subclass
In the preceding chapter, the principles of inheritance in ActionScript 2.0 were covered. In this chapter, an applied inheritance example, ImageViewerDeluxe, is introduced. The ImageViewerDeluxe class is a subclass of the ImageViewer class that was created in Chapter 5.

Chapter 8. Interfaces
An interface is an ActionScript 2.0 language construct used to define a new datatype, much as a class defines a datatype. However, whereas a class both defines a datatype and provides the implementation for it, an interface defines a datatype in abstract terms only; an interface provides no implementation for the datatype.

Chapter 9. Packages
A package is a unique place to put a group of classes, much as a directory on your hard drive is a unique place to put a group of files.

Chapter 10. Exceptions
This chapter covers ActionScript's implementation of handling "when bad things happen". In a regular programming language, this might be when a mathematical calculation results in division by zero.

Part II: Application Development
Chapter 11. An OOP Application Framework
Flash is notoriously open-ended. If there are several of ways to skin a cat, there are even more ways to build a Flash application. Flash's flexibility can cause confusion for developers, especially when they're building their first application. This chapter's goal is to overcome that confusion by providing one explicit example of how to structure an OOP Flash application. By no means is the example presented here the only way to create a Flash application, but it is certainly a legitimate, reusable approach that makes a good foundation for any OOP project. The example is considered in the abstract sense first, not in reference to any particular application. The framework could be applied to anything from an email application to a video game. In the next chapter, you'll see how to apply this generic framework to a real-world situation--a currency conversion application.

Chapter 12. Using Components with ActionScript 2.0
In Chapter 11, you were shown how to structure a basic OOP application in ActionScript 2.0. In this chapter, you see how to create a GUI application based on that structure.

Chapter 13. MovieClip Subclasses

Chapter 14. Distributing Class Libraries
This chapter discusses various techniques for sharing a group of classes (i.e., a class library) among multiple projects and possibly multiple developers. Flash MX 2004's class distribution features are not particularly refined; by far the easiest way to share classes is to simply distribute the source code. The book covers this easiest case first, before it discusses how to share classes without distributing source code, as you may want to do when selling a professional class library.

Part III: Design Pattern Examples in ActionScript 2.0
Chapter 15. Introduction to Design Patterns
A design pattern is a widely accepted description, with a recommended solution, of a design or architectural problem in object-oriented programming. Given a specific requirement, a design pattern describes, in general terms, how to structure interacting classes to meet that requirement. In other words, the pattern provides a general blueprint to follow when implementing some aspect of a program. This chapter is a general discussion of this idea.

Chapter 16. The Observer Design Pattern
Effectively, the Observer pattern is an all-purpose event-broadcasting mechanism. It lets a class broadcast generic updates to registered listeners, much as you could ask your local movie retailer to call you when a DVD you're interested in arrives. It could be used in anything from a mail application (when a new email is received) to a video game (when an enemy dies).

Chapter 17. The Singleton Design Pattern
Sometimes an application needs only a single instance of a particular class and should not create more than that one instance. For example, an order form might need one FormProcessor. A game might need one LevelManager. A text editor might need one GUIBuilder. Or a chat might need one SocketManager. In each of those applications, creating more than one instance of the FormProcessor, LevelManager, GUIBuilder, or SocketManager classes could cause problems. For example, having multiple SocketManagers might lead to multiple open socket connections, which would waste resources and potentially disrupt communications. To prevent an application from creating more than one instance of a class and to give various parts of the application access to that one instance you should use the Singleton pattern.

Chapter 18. The Model-View-Controller Design Pattern
In the MVC paradigm the user input, the modeling of the external world, and the visual feedback to the user are explicitly separated and handled by three types of object, each specialized for its task. The MVC pattern can be applied to a single user interface element (like a button), to a group of user interface elements (like a control panel), or to an entire application. This chapter uses MVC to create a clock that combines three user interface elements: a digital display, an analog display, and a toolbar for starting, stopping, and resetting the clock.

Chapter 19. The Delegation Event Model
In the delegation event model, an event is propagated from a "Source" object to a "Listener" object by invoking a method on the listener and passing in the instance of the event subclass which defines the event type generated. In this chapter, the concepts of the Observer pattern are applied to a more specific situation: implementing events for a class. The event implementation will follow Java's delegation event model, a general design for event broadcasting.

Part IV: Appendixes
Appendix A. ActionScript 2.0 Language Quick Reference
Appendix B. Differences from ECMAScript Edition 4

I surprised how much information was packed into this book. Colin really holds nothing back, but doesn't forget about the beginners in the start of the book where he explains the basics. This allows the reader to quickly move into the more advanced sections and ultimately end up with a wealth of knowledge that came from one head.

This book is targeted to users that are not new to programming. So, that's why I got the book since I know C++ and Java pretty well. But even if I didn't, and i knew some JavaScript (AC is JavaScript pretty much), I would also be considered as the target reader. With that said, these are my thoughts:
since I am not new to programming, that means I know the basics, I don't need lots of pages to tell me what a variable is in a super great detail; first pages tells me that I already should be familiar with it! This book spends a lot of pages on describing what ActionScript is: what is a function, how to create a class, variables, etc etc. Well, that is great, but ActionScript is A LOT more than knowing what a class is or what function is. I want to know what I can DO with it, and in this area this books fails totally. For example: I want to know how MovieClip object can be manipulated so I can put sensible code behind it and do something with it, or I want to know if I declare a variable, will it be visible on another timeline, or what I can do with the build in functions, etc etc. In other words, this book teaches ABOUT ActionScript, but nothing really what you can DO WITH ActionScript. Something like, if you know JavaScript language but don't know how browsers are using it, you can't program DHTML no matter how well you know JavaScript. Same here, this book will tell you how ActionScript is constructed, but you will not know what to do with it to make your Flash movie shine. ActionScript 2.0 Bible on the other hand teaches you what you can do with actionscript. So, either get both books, or get the Bible if want only one book.

since actionscript 3.0 has hit the scene in flex 2.0 and flash 9 is right around the corner, i'm slightly hesitant to recommend this book today (september 2006). BUT, the book is still great and if you are serious about programming in flash, i would say that it's essential material to learn. it's not a reference (although there is a small reference in the book) and it's not about how to program animation or do "cool" things in flash. it's about how to create custom classes and how to do it properly using best practices in flash. that's pretty much it. even as AS 3.0 crawls onto the scene, this book still gives a solid foundation and, from what i know about AS 3.0 so far, nothing you learn here will hinder you as you eventually move on to AS 3.0. the next version of actionscript will simply build upon what AS 2.0 has done. if you are still writing classes the old fashioned AS 1.0 way and feel like it's time to move forward, buy this book. if you've never written classes before, in any language, this book will show you how and provide a great foundation in doing so.

this book is not for actionscript novices, however. there are a lot of code samples and moock doesn't describe what the code is doing, apart from class-specific issues. so if you don't know what a "for loop" is, get "actionscript for flash mx - the definitive guide" first.

You can't go wrong buying this book or its predecessors by Colin Moock. I have done reviewing work of computer books for different publishers, and, wanting to learn ActionScript, I bought this book on the recommendation of a friend of mine, and he was correct in what he'd heard: this book is great. It's practically impossible to find any errors. The only thing I could wish were different is that some of the more basic and historical features of ActionScript (ones that haven't changed in version 2.0) have been covered thoroughly in his previous book on ActionScript, and as such, coverage of some of them is absent here, and considered covered in the other book. However, I noticed that some of this material is present at the author's website, where you can find a few complete chapters from the previous book that partially fill this gap.

This book is very technical, have good samples of oriented object. If you are a programmer and want to use your techniques in Flash, this is a great book. But if you don't have a good skill in Flash, I think should be better you try a book with more exercices and pratical samples.

If you wanna be 'inside' AS2 and its Class you should read this book.

This book is exactly what I have come to expect from Colin Mook and O'Reilly. It is a very well written, quality and informative tutorial on OOP with AS 2.0. This book goes great with Mr. Moock's earlier book; "ActionScript for Flash MX, TGD". I have come to cherish O'Reilly as a publisher and this book just reaffirms my complete trust that they put out some very good books.

I know that some developers want their books as dry as toast, but I don't. I've been a professional developer for about 30 years now, and I've lived and breathed OOP for many years. This book does a good job covering how Flash (MX 2004, not Flash 8, although the differences are probably minimal) works with OOP.

Still, my eyes glazed over a lot when reading this book. There is a way to write about design and programming techniques without boring people to death, but this book doesn't do it. Want an example of a book that covers OO in a unique, exciting way? Try "Head First Design Patterns". It's geared towards Java programmers, but I have yet to find a better description of design patterns, for any language.

I expected to be an Actionscripting Guru ready to pull in that six figure salary and move in to my million-dollar condo in San Francisco working for that elite consulting firm after reading this book. Well, maybe my expectations were too high. I should at least be pointed in the right direction in accomplishing everything I could ever want to do with Actionscript. The book covered above and beyond what the title suggests as 'Essential' yet you can't find everything. The book sums up the `Essentials' for those programmers that already have a good understanding of what they're doing and just need a summary guide of best practices. I liked the explanations associated with the more advanced topics that are uncommonly discussed in books dealing with Flash development. Because it's titled `Essential' the book may be better listed for reference rather than a teaching tool.
If you have ever read Macromedia Flash MX 2004 advanced for Windows and Macintosh
by Russell Chun you would agree with me that this book is the best step-by-step learning tool for Flash. Essential Actionscript 2 on the other hand forces you to sift through what seems like for the beginning Actionscripter a mound of words. I would have liked to have seen more examples to put into practice. Don't most techy people just want to 'cut to the chase'? Yet for the avid Actionscipter this book is excellent in its precision and conciseness on complex topics. In Spanish this is summed up perfectly in two words 'sin recovecos' as described in Carlos Rovira's review of the book (http://www.carlosrovira.com/books/eas2_moock.php).

For those that are ready to get down and dirty with Actionscript this book offers fully scripted examples. The core concepts are illustrated quite plainly. I was happy to finally "put a name with a face" with regards to some coding practices. Many times I've seen decompiled code but never could tie it to anything or knew how to use it. It was good to make those new connections within Actionscript. Of course there are several topics, though well discussed in the book, worth researching a bit further: type checking, upcasting, downcasting, method overloading, superclasses, and packages.
Don't start with this book to learn OOP programming. To get the most out of this book you should already have a good fundamental understanding of programming with objects. If you wanting to do animation and animation without Actionscript this may be the last book you want to pick up. With so many references to Java I had to keep looking back at the cover of the book to reassure myself I was reading an Actionscript book. I guess since Java is so robust all other languages must follow suit in scripting methods and practices. Moock describes it as the "Java mentality". He does a great job explaining this Java mentality. I wish I had this book last semester when I was taking Advanced Programming with Java. In my opinion, the Java mentality is most advantageous for those programming robust applications. But since you can get pretty far building animated cartoons, websites, games, etc. by employing basic programming techniques namely, array access and modularity, in Actionscript why would I need to frustrate myself further with this book? Moock also creates all classes strictly with Actionscript. For most multimedia developers you want to be able to use the right combination of your tools, Actionscript or bare-hand created vectors, for your solution. The more visually oriented your project is the less you'll want to hard code the classes of your graphic objects. Flash's great attraction is its fast implementation and maybe most importantly its instant eye candy. There is a fine line between developers and designers and this book leans more towards facilitating the developers end; however, more and more designers are implementing complex script into their projects. In learning a new language or technology I really like to be able to wrap my fingers around the whole subject before applying it to a new solution, in other words, I want to know what my bounds are and work my way in so I can use the best method and employ the best practice. Moock says, "There's more than a few ways of skinning a cat" when referring to application development. I would add to that there are many ways to do any Flash project for that matter. For this reason, learning Flash and its accompanying Actionscript can be quite daunting from the outset. How do you know your way is sufficient until you have seen it in a variety of ways? For a Flash novice or even an intermediate user I wouldn't make this book my first choice but probably with more experience I'd warm up to the "Java mentality" and learn how to adopt these more polished and superior programming practices.

This is a great resource, very thorough. Pretty much the only reference books I ever use are from Oreilly (the only exception being Robert Penner's book on Programming Flash MX). Easy-to-understand, well-indexed, and thorough.

As a freelance Flash developer, all too often I have to deal with other people's code. I am aghast at the horrid practices I see out: spaghetti code, cryptic variable names, and, worst of all, no sense of organization. Most Flash developers seem to have no concept of proper programming techniques.

This book show you how you're supposed to do it! Do yourself (and myself, and everyone else who has to work with your code) a huge favor--if you're an ActionScript programmer, or want to become one, read this book and do as it says!

Highly recommended.

after having finished the book, I would have to say that this book is geared toward java developers migrating toward actionscript.

it was a mistake for me to start learning actionscript with this book, becase all the examples in this book uses java methology.

the examples in this book contains lots of unecessary steps for the comfort of migrating programmers and is not geared toward just flash programmers.

if you have previous programming experience, i'm sure this is the best book for you.

but for the rest of us, I would recommend something a little easier to start out properly.

Have not read the book but paged thru it. I expected it would have a more detailed explanation of the syntax of statements and all parameters allowed with the statment. But it just shows a syntax with no explanation. It supposedly discusses object oriented programming concepts in detail, which would be helpful. It remains to be seen how well it explains OOP.

I bought this book when I saw it recommended in a forum about flash development and It's a must have for everyone that works with macromedia flash. It's clear and concise and It's one of the best programming books I've ever had.

I picked this book to help me further understand OOP in JSFL, which it did very well. ActionScript 2.0 and JSFL are similar enough to make this book a value to anyone wanting to get deeper into OO programming with JSFL.

Ok, you've read a beginner to intermediate book such as flash bible, unleashed etc. you've read one or more dedicated books on actionscript such as actionscript bible, cook book or flash hacks. You also practiced and built some projects using the knowledge acquainted from previous books. You can cope with the mentality of books on languages such as C++ or Java. You are ready and in need to get into the core of the theory of object oriented programming with actionscript. Only then this book is for you. Do not make a mistake by jumping into this book right away. This book is dry, theory intensive and not to the liking of the most graphically based mentality.

First of all, Colin makes this book an extension for his exploration of Flash Programming after his book ActionScript for Flash MX The Definitive Guide, which explain the ActionScript Fundamentals but Essential ActionScript 2.0 focuses almost exclusively on the Object-Oriented Programming aspects (in) ActionScript.

The book is divided to three main sections:-

1. Part I: The ActionsScript 2.0 language: discusses the theory of OOP in general, and itsimplementation in Action Script in particular. Colin really is great in clarifying the concepts in a simple manner with examples.

2. Part II: Application Development: discusses the concepts for the practical application, which is covered in the first section with examples describe the process of designing and deploying and object-oriented application.

3. Part II: Design Pattern Examples: Colin means by that how to apply OOP strategies to a many approaches to various programming situations in Macromedia Flash.

· New to OOP Programmers will learn the basics and how to apply it.
· Familiar with OOP Programmers will gain experience with Flash-based OOP.
· Experienced Flash developers and programmers coming from other languages will enjoy the deep coverage and expertise in Essential ActionScript 2.0.

Finally and in sum, this book reviews the Object-Oriented definite structures in ActionScript 2.0 realistically to get benefit from applying these concepts through the abstract theory and the practical tips.

Let me first say that i had no programming (OOP) knowledge at all, the only developing i did was in AS.The book took me step by step into the world of OOP,explaining every concept and idea of OOP(both AS and other langs).This book is even understandable for people whom English is not their mother tongue(like me)...so...this is a good one.

Colin Moock does a great job here by writing computer code / projects that cover a lot of ground. One particular trait of his writing is that he does not reserve any shortcomings in Flash/Flash Player itself, and good advice for how to write hacks around this. Colin also goes into good, thoughtful details on how Flash handles objects. The last object oriented language I programmed was C++ and this was a great refresher to OOP.

I highly recommend this book to anyone of all levels of Flash scripting that wants to improve his/her programming skills.

Colin Moock, the punk rockstarish English major once again writes a great text on ActionScript this time covering the class based object-oriented nature of ActionScript 2.0. Moock's text was well supplemented by the supporting information that he offers at moock.org. The rich education in object oriented programming is worth every penny of this text.

On the front cover of this book is written "Object-oriented development with ActionScript 2.0." That's a good summary of what this book covers. The focus is clearly on ActionScript, with an emphasis on building classes and using objects.

The book provides a good, but brisk, introduction to object-oriented programming (OOP). If you're new to OOP, you may need to wallow for a while in the first few chapters. That being said, I do think it's possible (with patience, determination, and a commitment to look over the code samples carefully) to use this book as the basis for your first exposure to OOP. Some of the concepts may not "click" until you work through the examples in later chapters.

If you have experience in other OOP languages, this is an excellent book to learn the peculiar ways of object oriented programming in ActionScript 2.0. The book is easy to read and flows well. Although I will definitely value this book as a general ActionScript reference, I enjoyed it as a cover-to-cover read -- a significant accomplishment considering the rather dry subject matter! The book is sufficiently thorough, but doesn't include much fluff ("just right" -- which is typical for O'Reilly books, in my opinion).

A key to understanding this book is noting that it's title is "Essential ActionScript 2," not "ActionScript 2: The Definitive Guide." If you're looking for a complete treatment of the language, look elsewhere. If, however, you have a good working knowledge of ActionScript 1 (AS1) and are considering a move to ActionScript 2 (AS2), then get this book.

Also note that the title of this book is not "Essential Flash MX 2004." I agree with other reviewers who would have liked to see more coverage of topics such as data connectivity. That said, I like how the author kept his focus on the ActionScript language. Many topics, such as the new components, have much more to do with updates to the Flash Player than to the scripting language. They are certainly related, but a developer can utilize most of the new components without writing a single line of ActionScript, and can realize the benefits of AS2 without ever using one of the new components. A discussion of these components would have been welcome, but I can see why he left them out. This book is primarily about understanding and using AS2.

To say that this book covers the "essentials" does not mean that this is a primer on the ActionScript language, nor that it is written for beginners. The author's explanations often draw on comparisons to AS1 and other languages, especially Java. If you are unfamiliar with AS1 or Java, you will probably find such explanations less than satisfying. If, however, you are at least somewhat familiar with these other languages, you will find most of these explanations interesting and informative.

Among the features I found most useful in this book were the discussion about new features and benefits of AS2, especially with regards to continuing to develop for Flash Player 6. It answers very well the questions of why I would want to switch to AS2 and when I can use it. His examples do a good job of demonstrating new features of the language and how AS2 opens the door to more functional Object-Oriented Programming using external class files. He does an excellent job of pointing out not just what to do and how to do it, but _why_ you should care or take the extra time to do it. He demonstrates, for example, how classes and datatyping can take some of the headache out of Flash debugging.

The best thing I can say about the book is that I was able to apply it immediately to my code, which I suppose is really the only thing that matters. The book answered my practical questions about switching and I was able to begin using AS2 immediately and know why I was doing it. AS2 has its problems as a language, but if you develop for Flash you need to know it and use it. If you need to know and use AS2, I would definitely recommend adding this title to your library.

There are certainly enough reviews of this book to give you a good sense of the quality content that Moock is known for. I wanted to simply offer an opinion regarding who this book is for, as opposed to simply praising the content.

After reading the book, I feel empowered. But I'm not like every other Flash person out there. So lets look at who is using Flash, and what this book means to them. Generally speaking there are Flash Designers, and Flash Developers. Designers come from a graphic arts background, and are often familiar with timelines, tweening, keyframing, and other aspects of animated design. Developers have an interest in these things, but are more focused on building rich applications that require hundreds or perhaps thousands of lines of ActionScript code.

This book is for the novice developer, or the designer who wants to become a developer. Moock smartly points out that Object Oriented Programming is not always neccesary for all Flash projects. Therefore, this book is not neccesary for the Designer who wants to build Flash applications which are predominantly animation and graphics. But once the designer finds that they are writing so much ActionScript that it's tough to keep track of it all, I think its time to get this book and become a developer.

Pretty much similar to the argument about PowerPoint that "PowerPoint is the source of evil of bad (visual) design", the "EAS 2.0" version says that "design pattern is the evil of bad design". My personal experience proofed it on one side. Without any formal programming background, I happened to pick up the book when I was trying to simulate some complicated and intimidating control system (similar to cell phone control menus) using Flash. The book helped a lot in terms of teaching me how to think and plan. I found myself trying to "abstract" things before heroically and blindly "hacking" through. The design patterns that have been covered in the book: "Delegation", "MVC" and "Singleton", are the everyday necessity for so-called "Flash visual developers"; also object-oriented design and programming are taught in a very practical and lucid manner. I am happily on my way to fulfill my dream of becoming a "real" visual developer (Yike!;)) after picking up this book.

When discussing some details, the book tries to keep a balance between clarity, simplicity and accuracy. But being accurate seems to help sort out the "why" part of the problem when you are learning a new language.

Geng Wang
FlashCodersNY.org

This book is a new cornerstone in my Flash reference library. Explains not only the 'what' and 'how' of Actionscript 2.0, but the 'why'. As an intermediate-level actionscript 1.0 programmer, this book gave me the information (and the encouragement) I needed to upgrade my skills to AS2. Part III, which introduces various design patterns, was especially eye-opening to me as a 'learn-as-you-go' programmer. Colin's easy-to-read conversational style makes this book a readable reference that makes OOP approachable.

Lisa Larson
www.FlashCodersNY.org

Though you'll be bleary-eyed and exhausted at the conclusion of each lengthy and dense chapter, the book is worth adding to your ActionScripting Library (right next to ActionScripting in Flash MX by Philip Kerman, which is the only ActionScript book I'd give 5 stars)
The only real shortcomings here (other than the lack of data connectivity topics, as another reviewer noted) are the author's occasional forrays into how ActionScript compares to Java (not learning Java so I don't care, thank you), and the occasionally convoluted examples (you can tell someone used to work at Macromedia when they weave four different concepts into one example, obfuscating the topic at hand).

//Also annoying are explanations
//commented out in code samples
//instead of beside the code in
//callout boxes. This makes all
//the scripts four times as long
//as they need to be, and much
//harder to read.

Nonetheless, the author does do a good job dividing the content onto fundamental OOP concepts, and includes a usefule appendix covering methods and events of all the classes (noting the errors in Macromedia's own documentation).

For someone without any programming experience outside of ActionScripting (like myself), this book is challenging to plod through, but doable. But learning ActionScripting is like learning to practice law (instead of learning every statute on the books, lawyers focus on legal prcedents, and research their own issues). That's what this book is like: a primer on advanced ActionScript "precedents". After reading it, you'll have a better general understanding of how solutions can be implemented, but you'll still need to visit the Flash Developer Center and the HELP panel to make applications that really work.

-This book provides a great introduction to OOP concepts, design patterns, coding styles and other techniques that are vital in producing quality applications.

-This book will be used mostly as a learning tool, and not so much as a reference tool.

-I am working on developing some applications but nothing too complex at the moment. If you are looking for a book to develop simple applications, or just a want a reference guide to flashMX objects and components DONT buy this book. But, if you are however developing more complex applications that need to be upscaled later, are connected to external datasources etc BUY this book. It will give you examples of best practices and ways of solving your application development questions. Another plus comes in the fact that it is based on ActionScript 2.0, so you will be coding with the most up to date, highest performance and capability available today.

Have you ever read Essential ActionScript 2.0, by Colin Moock?

It's the blockbuster followup to his action packed Actionscript for Flash MX The Definitive guide and it just getting crazy as I read it. Now variables HAVE to be declared. It's like a fascism that these variables have to declare what type they are before anyone can interact with them. I picture them scurrying around the system architecture as if it were post-War Prague, carrying their papers just trying to get to their destinations. But there's more! There are ways around variable declaration, that fool the system into thinking one variable type is quite another and doing this brings about _system instability_. Yes, the revolution is on as some variable sneak through the system passing themselves off as others and then throwing a monkeywrench into the works. This is edge of your seat intrigue as only the Master, Colin Moock, can bring to the table.

Colin Moock is extremely talented in all areas of Flash, and object oriented programming.

In general, this is book has very good ceverage of actionscript best practices, when implementing an application that uses the AS2.0 class framework. That is what gets the 3 stars. Now the missing part. I include myself in the 99.9% of all Flash MX 2004 developers that are building Rich Internet Applications. Rich Internet Applications need to connect to and update data, whether using Flash Remoting, Web Services, or both. This book gives no coverage to data connectivity using the runtime Actionscript 2.0 classes. Although you can accomplish this in the authoring environment, this has a negative effect on runtime performance, as well as not adhearing to the MVC design approach that object oriented programming promotes. There are currently no books that cover the data connectivity classes in AS2.0, a fact I find to be truely unbelievable.

As a long time Flash Developer and having used ActionScript 1.0 extensively, I have really benefitted from this book. Colin answers so many questions about best practices and takes an extremely practical approach to Flash development - obviously born of considerable experience. His explanation of OOP is very good as well. I can't recommend this book enough. Just get it - it has the answers you're looking for.

I'm a java / C++ developer, and my first Flash MX apps were good, but lacking in standard OOP practices. After reading some other OOP books on actionscript, I was still lacking. Then with the release of MX 2004 and Actionscript 2.0, I knew that I was only a stones throw away from crossing the oop divide. This book was that stone. Moock has done a wonderful job of finally laying out how to utilize the flash environment to create robust applications.

My favorite section is the portion on Patters. Some great patterns in there that you will use over and over again.

My last advice would be for those of you who are interested to swing by the Actionscript community online. And starting with the flash blog agregator is a great place to start.
(...)

I have Flash MX 2004 Pro (the software), but have so far mainly used MX (Flash 6) as I have no programming background and had no idea about all this "classes" thing.
This book has explained everything to know, from classes, subclasses, interfaces, coding practices etc, to code libraries, packages, typing, swc export, and patterns.
Thanks, Colin, now I'm ready to start using MX 04!

At right around five hundred pages this book is just about the right length to cover the core of the Actionscript 2.0 language. It's split into three parts with the vast majority in the first part which covers the language fundamentals; the new typing structure, the new class structures, exceptions, interfaces and the rest of the language enhancements.

Part two, which is only about sixty pages, is where the book touches metal on the Flash player. So be warned, this book does not cover both the language and the Flash player context. It covers the language in depth.

Part three covers design patterns, which personally I think is optional in this context. Though the coverage is restricted to the most commonly used design patterns; observer, singleton, model-view-controller, and delegation. And these all have their uses in the Flash client coding context.

The majority of the book is solid, tight introduction to the entire language of Actionscript 2.0, not just the new features. I gave the book four stars instead of five because of the limited emphasis on reference materials, and the minor diversions into the Flash Player environment, which wasn't too bad, and the patterns stuff, which while it was well done, was strictly optional.

What a relief! I thought my project was a death march. Between:

-- the enormous changes from AS 1.0,
-- the bugs (perhaps not all that many, but occuring in critical spots), and
-- the overly terse (to say the least) documentation from MM,

I was ready to give up and become a greeter at Wal-mart.

That's not to say that THIS book is verbose, because it's not. It is extremely terse, but not OVERLY terse: I read it with a highlighter in one hand, just to mark the sentences that would have been paragraphs if word-count were directly proportional to importance. Colin Moock says it once, and you'd better get it on the first pass. That's not a complaint, just an observation; a heads-up for those who skim. Pay attention!

However, if you do pay attention, the essentials are all there, as advertised. They are in a logical order, they are well presented, and (hallmark of an experienced teacher) the consequences of mistakes are included. Just as good street directions include an "if you see _____, you need to turn around" clause, this book tells what will happen if you ignore an "essential" (or, for that matter, if you just choose a different way to skin a given cat.)

In the same way, Moock is aware that this is an imperfect world; that object-orientation is a tool that makes sense in some situations, but not in all; and that sometimes good-enough is perfect. Not an OOP absolutist approach, at any rate.

MM's implementation of ECMA script may be lacking in some of the finer points, and in some of the grosser points as well, but AS 2.0 is coming in, and AS 1.0 is going out -- at least for OOP. If you have any intention of adopting OOP practices in your Flash programming, you need this book.