Customer Reviews

Object-Oriented ActionScript for Flash 8

5 star:		(8)
4 star:		(4)
3 star:		(2)
2 star:		(1)
1 star:		(1)

 

 

I finally decided to take the plunge into OOP after I realized that is where Flash is headed. With the advent of ActionScript 3.0 around the corner (or out now if you're already dabbling in it), you just know that everything is soon going to be class based. This book is a great start to your journey, as someone who originally started to read Colin Moock's Essential ActionScript 2.0 will tell you. It is a LOT easier to read than EA2.0 as I'm not well versed on theory nor do I, at least at this point, really care that much about it. I'm one of those people who want to dive in and learn the syntax/usage, and then I'd like to figure out where it all stems from, not the other way around as it just makes it harder for me to learn that way.

The beginning chapters are great and teach you very much about the basics of OOP. If you're an experienced programmer, you honestly probably won't get much out of this book as this would all be stuff you already know. If you're a beginner, however, this is perfect for you. As a pro (and a con on some level) of this book, some of the pages explain how to set up the document before you work on it. This is good for people who are new to Flash, but in my eyes if you're new to Flash you shouldn't be reading an OOP book to start you into programming as this won't help you really learn the syntax. If you're using this book, it should be assumed you already know the basic Flash syntax and won't need to be told how to set the document size (pages 84-92 are basically wasted on setting up a document for coding one of the examples).

There is a chapter on design patterns that is really good and explains their functionality pretty well. One thing to note in this chapter is that it comes kind of early in the book and sometimes (at least for me) it was hard to grasp the whole concept of what the Model View Controller, for instance, was doing because I'm still not thinking in terms of OOP, rather procedural, so I had to go back and re-read some of the design pattern stuff a couple of times to fully understand it (and I'm not sure that I do still to this point, but that's outside of the scope of this book).

The one knock I have on the book, which really is a non-issue to be honest, but it's a bit funny to see all the editorial errors through these technical books. It makes you wonder if the editors really read the whole thing or just skim it.

I feel this book definitely gets me ready to move on to greener pastures, a la Essential ActionScript 2.0, which I should now be ready to dive into. I don't feel like I'm an OOP expert after reading this, but I don't think that was the main point of the book. Of course, I learn a lot slower than others because I have a design background and no programming background whatsoever, but the book was painless to read and I enjoyed it greatly.

Don't get me wrong if this review is sounding half negative, the book is essential to anyone getting started with OOP (as I am), and I highly recommend it. I just tend to point out everything I notice and sometimes I don't always write down all the positives so my reviews seem to lean towards the negative a bit more. In no way does this mean this book is bad, because it really isn't; it's a great book.

There have been several OOP books as it relates to Flash development. There is the Moock AS2DG (a chapter or two if I remember), the Branden Hall/Sam Wann book, a few others, and then this one.

What makes this book really interesting is that its a wonderful read. There is a sincere sense of flow. It isn't a section followed by another, without glue to hold them together. Each part of the book works you through principles and concepts - with straightforward code examples - in a language most will understand.

It covers some great topics, like design patterns (not simply mvc), UML diagrams, manager classes, some cool ways of using new Flash 8 capabilities using OOP constructs, etc.

Yes, it does start out a little basic. But to those of us without CS degrees, we have probably picked up our knowledge through books, online articles, etc. Perhaps there was a detail here or there to pick up in those sections for everyone.

This is a GREAT book - pick it up even if you have other OOP/Flash books you have purchased. This will be a great addition to your tech library - trust me. Its one of the best books on the subject (without being overly technical) that I have seen. Its actually readable (you don't necessarily only want to use it for reference like other books).

Before reading this book I thought that OOP meant writing a class and applying it to as many objects as I wanted. Was I ever wrong! This book not only gives you thorough explanations of what OOP is, it also provides detailed explanations on why you should use it. It's hard to explain the misconceptions that many people can pick up by trying to learn OOP by reading random articles around the web. This gently leads you through all the elements of OOP and clears up any of the misconceptions you may have previously had. It even teaches you programming techniques and design patterns such as how to separate the data and control from the style as well as how to manage multiple styles, colors, sounds, etc. with one class and dynamically apply them to whatever objects you want.

Elst and Yard develop a good foundation of planning, workflow, and best practices without preaching their way as the only way. It is nice to see them agree that there is more than one way to write code and whichever way works best for you is the best way. Once they dive in to teaching encapsulation, polymorphism, and inheritance through examples you will have a clear understanding of what these terms are and why they are so important. In fact, what I loved the most about this book is that it clearly teaches all the benefits of OOP instead of just teaching how to use OOP.

You will honestly come away from reading this book eager to create your own OOP packages or even components and you will have the knowledge and confidence to put them together. If you are looking to start developing Flash applications or advanced interactive websites, this book is worth every penny.

I think this is a beginner friendly book to learning and developing Flash 8 Object Oriented code. The book is an easy read and has a pretty good introduction to Flash. It even goes into like 4 design patterns which if you are an OOP developer is generally the next step in design and architecture.

A few things I don't like about the book is a couple of the chapters are very thin. Like the chapter on interfaces is very minimal. Also, their case study project at the end of the book is very weak. It's a Time-Sheet application and it's a little dry in terms of the power of OOP.

Overall I recommend this book for any beginner looking to get into OOP with Flash. Just keep in mind though that Colin Moock's books are much more thorough and look for his latest book on ActionScript 3.

Object-Oriented Actionscript for Flash 8

Introduction:

Object-Oriented Actionscript for Flash 8 from Friends of ED (Apress) is a great book for intermediate and advanced Flash Developers who want to learn more about OOP and AS 2.0. This books is definitely not intended for Flash Designers or those with limited experience in Actionscript. This book would be a great introduction to Actionscript 2.0 for any traditional computer programmer with experience in Object-Oriented programming techniques who is looking to start developing Rich Internet Applications with Flash.

First the bad news:

While the majority of this book was full of useful information, I believe their are a few chapters that are completely out of place and should have been removed from the book. The Planning and Project Workflow chapters should have been combined into a one or two page reference located in the back of the book. Since the intended audience is someone that should be familiar with advanced web development, there is no need to include any information about CVS. This could have been written in one sentence... "Any good programmer will utilize some type of file storage and source control application, and I recommend using blah blah blah software." I almost stopped reading the book at this point and had to force my way through the text.

Now for the good news:

The writing style, or "voice" as some people call it, was excellent. It did not feel like I was trying to read a programming book, and instead felt like a colleague or personal friend was giving you a training on the subject matter. I also thought the the Design Patterns information was very informative and I felted like I could immediately change some of the programming techniques in my current projects to have them run more smoothly.

The Media Player Case Study was spot on! How many clients have asked for a media player as part of the requirements of an application? This is a "real world" example that I will study and use hundreds of times, unlike some so-called "real world" examples like XYZ Corp needs a web site to view their magazine subscriptions. I have read a few other books on this subject, and most of them use way too generic examples that will never be applicable unless you actually land that Bank Client who needs a home loan calculator! Although, there was a semi-useless timesheet example at the very end of the book :)

I also enjoyed reading about the tweening techniques used in the OOP Animation and Effects chapter, along with the much needed explainations of how Flash components can be used with OOP in Rich Internet Applications.

Conclusion:

While there is room for improvement, I would highly recommend this book to any advanced programmer or an intermediate Flash Developer looking to better their already established Actionscript 2.0 skills. The Media Player example is enough to make this book worth the money.




Book Rating: 9 / 10

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.

In the last 7 years, I've bought over 30 books on Flash and Actionscript. Usually I'll get through the first 20 pages, get bored, and skim through the rest. This book is hands-down the best book on Actionscript programming ever written to date. It's excellent for three reasons: 1, it teaches you to code with object-oriented standards, 2, it teaches you to code with object-oriented standards, and 3, it teaches you to code with object-oriented standards. Furthermore, it's written in a very easy-to-understand format that could take anyone off the street and turn them into an Actionscript professional.

A MUST-read for any Flash developer that doesn't already live, breathe and die object-oriented practices.

Ce livre est fantastique. Vous allez découvrir l'autre face de Flash 8 grāce à P.Elst et T.Yard. Fini de bricolage, ils vous livrent les meilleures bases de la POO pour AS2. Et je peux vous dire que AS2 n'est pas mort.

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

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.