Advantage and Disadvantags of ActionScript 3

Said,


> Please tell me advantages and disadvantages of both
> [versions of] ActionScript. Please advise which is
> powerful and has more info and sources.

ActionScript 1.0 and 2.0 both run on the same virtual machine (AVM1)
inside Flash Player. As of Flash Player 9, the player runtime features two
virtual machines (AVM1 and AVM2), the second of which runs ActionScript 3.0.
Right off the bat, this tells you that Flash Player 9 or higher is required
if you want to program with ActionScript 3.0. In one sense, that's a
potential "disadvantage" of AS3: if your users have Flash Player 8 or lower
installed, you simply can't use that version of the language. Instead,
you'll have to use AS2 (as far back as Flash Player 6) or AS1 (as far back
as Flash Player 5), or slash-notation proto-ActionScript if you need to go
even further back than that. Ultimately, then, the version of ActionScript
you use depends on the version of Flash Player you expect your users to have
installed.

AS2 is the first version of ActionScript to officially support custom
classes (external text files structured in a particular way, using folders
for classpaths and the "class" keyword). For more information on
classpaths -- written for AS2, but basically applies to AS3 -- see this URL:

http://www.quip.net/blog/2006/flash/understanding-classpaths

For many people (myself included), custom classes provide a powerful way
to organize code into reusable objects -- just like the given objects in
ActionScript's native API. Be aware, however, that custom classes are *not
a required workflow* in AS2 or AS3. If you prefer, you may place your AS2
or AS3 code into timeline keyframes, just like with AS1. Contrarily, even
though true classes are not officially supported by AS1, you can mimic many
of the benefits of classes by following the instructions here (an incomplete
resource, but very useful):

http://www.debreuil.com/docs/

It would take pages and pages of notes to give you a thorough list of
the benefits (and disadvantages!) of every version of ActionScript. Even
then, it would be difficult to demonstrate that such a list was complete, so
to keep things simple: as a general rule, each new version of ActionScript
is presumed to be better than its predecessor. AS1 was more powerful than
Flash 4-era ActionScript because it provided a considerably larger API. AS1
also made it easier to target objects with dot notation than with slash
notation and cumbersome getProperty() and setProperty() functions. AS2 was
more powerful than AS1 because it provided native support for classes. It
introduced variable typing, which helped with code completion and
compile-time error checking. (AS2 also coincided with an even larger API,
but that's a parallel benefit due to increased functionality in subsequent
versions of Flash Player.) AS3 is more powerful than AS2 because the syntax
of custom classes has become more strict. I personally find that stricter
syntax helps a programmer avoid "lazy" or "sloppy" practices, encouraging
the programmer to code with purpose.

For more thoughts along these lines, here's a free excerpt from a book I
recently co-authored for O'Reilly (bear in mind, these are largely
subjective opinions, but they work for me):

http://www.communitymx.com/abstract.cfm?cid=16D76

I'll probably start repeating myself soon, but to sum up: AS2 has
advantages over previous versions because it provides numerous options and
improvement in ease of use. AS3 improves even further by "cleaning up" the
language by making it more strict and by providing a stronger internal
consistency.

Here are a few quick examples.

In AS2, to create an instance of the Sound class (that is, an object you
can use for programming audio), you simply use the "new" keyword:

// AS2
var mySound:Sound = new Sound();

Most classes can be instantiated in this way, but in AS2, there are
notable exceptions, including movie clips and text fields.

// AS2 -- this does NOT work!
var myMC:MovieClip = new MovieClip();
var myTF:TextField = new TextField();

This can be confusing to a newcomer, because it seems so arbitrary.
(Someone new might well think, "Why can't instances be made the same way
across the board?") In AS3, instantiation is more consistent:

// AS3
var mySound:Sound = new Sound();
var myMC:MovieClip = new MovieClip();
var myTF:TextField = new TextField();

This is also true for event handling. In AS2, there are four or five
ways to do it: the on() and onClipEvent() functions, their dot notation
equivalents, addListener(), and addEventListener(). They're all valid in
AS2, but not all interchangeable. Some work for components, some for other
sorts of objects. It takes effort to memorize which objects work with which
approach. In AS3, outside of a very small number of exceptions, most event
handling is done with a single, consistent approach: addEventListener().
For a newcomer, this is easier to learn because once the technique is
understood, it works in nearly every scenario.

As far as performance is concerned, AS3 trumps AS2 significantly. AS3
performs better and faster than all previous versions of ActionScript -- but
you'll only notice this with complex applications, especially those
involving a high volume of number crunching.

Here are a few more links that may prove helpful to you:

ActionScript 3.0 Overview
http://www.adobe.com/devnet/actionscript/articles/actionscript3_overview.html

Tips for Learning ActionScript 3.0
http://www.adobe.com/devnet/actionscript/articles/actionscript_tips.html

ActionScript 3.0: Is it Hard or Not?
http://www.insideria.com/2008/01/actionscript-30-is-it-hard-or.html

You also asked which version of the language has more "info and
resources." By that, I assume you mean online resources, such as blogs,
tutorials, and so on. That question is hard to answer, but my *guess* is
that there are still more resources online about AS2 than AS3 ... but AS3
will probably catch up soon.


David Stiller
Co-author, Foundation Flash CS4 for Designers
http://tinyurl.com/5j55cv
"Luck is the residue of good design."