So this was the third book I read on Object-Oriented Programming for ActionScript 2. So my thoughts are in context of having already been through Moock's excellent Essential ActionScript 2.0 (which did wonders for solidifying my OOP knowledge), and then the dismal New Riders Object-Oriented Programming with ActionScript 2.0 (VOICES) (which was disappointing at best). So, by the time I read Elst and Yard's Object-Oriented ActionScript for Flash 8 -- hereafter referred to as OOA4F8 -- I was already well-versed in the ways of OOP (and for the record, I'm a full-time ActionScripter). I was actually reading the book for the purposes of evaluating the book as a potential text book for a class I taught. So, my opinions are coming from someone who already knew most of the material.

Friends of Ed books are generally pretty good at taking things slow and not assuming too much; this is a great feature in technical books, and OOA4F8 manages to follow suit for the most part. In fact, the first section of the book that introduced general OOP concepts, without getting too much into actual AS, was probably the best such introduction I've seen, heard, or read. It pretty much sold me on the book as a usable text book.

But then I read the rest of the book. Now, for the most part, the explanation of concepts and techniques was adequate to good. However, the further along in various techniques the book took me, the more I disagreed with the approach taken by the authors. One standout example for me is the "IntervalManager" (or perhaps it had a different name, but it was the class that managed your setIntervals). At first I thought, oh, that's a cool idea. It might make the whole making-sure-you-clear-before-you-set thing a little easier. Or maybe it would automatically control the number of repetitions for you. Or something more robust like the Timer class in AS3.

Unfortunately, I saw no value in the IntervalManager. It did not allow you to write less code, and it did not add any functionality beyond what was already available. I may be remembering it wrong now, but you still had to manually clear intervals before setting them, and the code to set up an interval with the new class was virtually the same as what I would normally do, except with a different API.

My recommendation depends on how programmatically-minded you are. If you're a decent ActionScripter already and just need to make the transition from procedural AS to OOP AS, the go with Colin Moock's Essential ActionScript 2.0. It's detailed, technical, and assumes a certain level of knowledge going into it. I found it extremely well-written and made several advanced OOP concepts clear to me. However, if you're a little more left-brained and need a gentler introduction to all things OOP, I would recommend this book, and ideally, then follow it up with Moock's book to iron out some of the disagreeable practices from OOA4F8.

I wanted to learn something about the OOP in Actionscript, and first 12 chapters went well, I was satisfied that I understood everything - it even seemed too easy to me (some examples not very practical ones). But from chapter 13 there is a big jump into very difficult matters which I had a lot of trouble to understand (I had to skip many pages). Generally, in the book there are either very easy or very difficult things (beginning from chapter 13), and some examples on intermediate level are missing - as well as some exercises for the readers who could try to do some work on their own (under the author's guidence).
Anyway, a good book, anybody who has read it and understood everything, can be proud of himself as a great professional. Unfortunately, I am not one of those...

This book is a great introduction to OOP. If you are a hardcore programmer then you'll be a bit bored, but for the rest of us who "kind-of" get it, this is the book for you.

The concepts are good and the application of those concepts are solid. The test code works great. I would reccomend this book to anyone who wants to do more OOP work in flash and is more of an artist than a programmer.

Overall a disappointing, confused book without much of an audience. This book assumes advanced actionscript skills, the most advanced skills I've seen in books teaching flash/actionscript. Here's an example from the first case study:

static public function setInterval (
connection:Object,
intName:String,
path:Object,
func:String,
time:Number ) :Void {
clearInterval(connection, intName);
if (connection instanceof MovieClip) {
if (__listeners[connection] == undefined) {
__listeners[connection] ={}; }
__listernes[connection][intName] = _global.setInterval(path, func, time, arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10]);
} else {
if (connection.intervalID == undefined) {
connection.intervalID = "int" + (__intervalID++);
}
__listeners[connection.intervalID] ={};
__listeners[connection.intervalID][intName] = _global.setInterval(path, func, time, arguments[5], arguments[6], arguments[7], arguments[8], arguments[9], arguments[10]);
}}}

If this code looks alien to you, steer clear until your AS is strong enough or be prepared for lots of headscratching. Colin Moock's book, Essential Actionscript 2.0, is far friendlier to intermediate AS users and I recommend getting to know that book from cover to cover.

It's one of the more painful book I've came across.

Poorly edited,and poor accuracy. If I could get a refund, I shall be happy to.

New concept are added with no mention whatsoever, in the tutorial.

Additions to files are added with no mention to the files names.

From chapter 1 to 12 I've trudged, but I'd say this book needs a strong review.