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

I really enjoyed the writing style, the good examples and analogies and the sample projects with which to work. This book has helped make me a much better AS coder. I couldn't have completed my last big project at work w/out it!

My only nitpick is that it talks way too much about AS1 at the beginning when it's bringing those who've never coded and those who've only coded in AS1 up to speed. I'm trying to gear up for AS3 and talking about AS1, which frankly I've never even used, was kind of a waste for me, though I understand it wouldn't be for others.

This has to be one of the "must-buy" titles for any flash developer wishing to use OOP in his programming tool kit. This book gently guides the reader through all the key concepts of OOP and more importantly backs them up with simple but concrete examples. Please don't underestimate the importance of 'simple and concrete,' because when it comes to explaining, 'Design Patterns,' try and read just about any other book out there including Colin Mook's very excellent, "Essential Actionscript 2", and you'll soon learn how the theory and the complexity can have your head swimming. This book, on the other hand, makes learning fun and the authors deserve some kind of accolade for so succinctly rendering the concepts in well chosen but accessible terms.

Before you read this book you should already know Actionscript and Flash. The point of the book is to teach you object-oriented concepts along with more advanced ActionScript concepts, so it does not include a tutorial on ActionScript basics, though it does have a brief section at the beginning of the book on object-oriented concepts separate from ActionScript. Other reviewers have described this book as "painful". Since I already knew object-oriented concepts before I sat down to read this book, perhaps that is the reason that the whole thing made perfect sense to me. The following is a brief description of the content in the context of the table of contents:

PART ONE: OOP AND ACTIONSCRIPT
Chapter 1: Introduction to OOP - The basics of OOP including classes, objects, encapsulation, polymorphism, and inheritance.
Chapter 2: Programming Concepts - Programming constructs in an OO context.
Chapter 3: ActionScript 2.0 Programming - A quick overview of ActionScript

PART TWO: FLASH OOP GUIDELINES
Chapter 4: Planning - How to plan your OO structures, analyzing a Flash ActionScript project, modeling with UML
Chapter 5: Project Workflow - version control, rapid application development, extreme programming, usability testing
Chapter 6: Best Practices - proper formatting, naming conventions for variables, commenting your code, alternative programming styles

PART THREE: CORE OOP CONCEPTS
Chapter 7: Encapsulation - Encapsulation via a moving ball in timeline code
Chapter 8: Classes - Practical implementation of classes via the Mover class for the Ball of the previous chapter.
Chapter 9: Inheritance - Implementing inheritance via the Bouncer and Gravity classes
Chapter 10: Polymorphism - Polymorphism in practice
Chapter 11: Interfaces - Practical examples of interfaces
Chapter 12: Design Patterns - What they are and what is good about them. Introduces the Observer, Singleton, Decorator, and MVC patterns.
Chapter 13: Case Study: An OOP Media Player - brings together OOP concepts learned so far in a single ActionScript example.

PART FOUR: BUILDING AND EXTENDING A DYNAMIC FRAMEWORK
Chapter 14: Framework Overview - outlines the core classes of the MX Framework, specifically MovieClip, UIObject, UIComponent and View
Chapter 15: Manager Classes - How to build your own manager classes for a Flash component framework.
Chapter 16: UI Widgets - Building visual components that handle standard UI functionality that leverages the work done in chapter 15.
Chapter 17: OOP Animation and Effects - Explores classes that alter video clips using ActionScript effects available in Flash 8.

PART FIVE: DATA INTEGRATION
Chapter 18: Interrelationships and Interactions Between Components - Data binding as a means of sharing content between components.
Chapter 19: Communication Between Flash and the Browser - how Flash movies communicate with their container.
Chapter 20: Server Communication (XML and Web Services) - Two efficient means of how Flash communicates with data sources across server connections.
Chapter 21: Case Study: Time Sheet Application - A capstone application that brings together everything introduced in this book.

I thought the book was very well laid out and clear. It does not go on for pages with nothing but text and theory and then do a code dump on you. It discusses each concept and then has a short code snippet to illustrate the point. If there is confusion about where to store a file or where to find one, the book gives detailed instructions and even screenshots. Even though this book is using the out-moded ActionScript 2, it does concentrate on object-oriented design and good design in general, so it is probably still a worthwhile read.

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.

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.

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.

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.

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

If you have a programming bkg this book might not be directly relevant to you since the first 170 pages or so are dedicated to the explanation of basic OOP concepts.
It does a great job in explaining those basics of oop, and smoothly introduces and explores design patterns and further.

I found that the Moock book had more depth in its exploration of oop with actionscript(also its scope is different since it aims at programmers with a different background as to novices), but the Elst/Yard book has a different approach in its explanation of concepts.
It's more hands-on, the code-examples are really relevant and the build up of the book and concepts is very fluid. It reads well, it's enjoyable and is very clear.
I feel that a lot of people, just like I did will draw comparaisons in betweeen this book and the Moock one, and to be honest I would say that having both doesnt make any of the two redundant, far from it, they are very complementary.

I would recommand to read this book before reading the Moock one though, yet both are a must if you seriously want to use oop in flash.