Links

Sunday, March 25, 2007

ActionScript Typing

In the blog post,
"The Open Web and Its Adversaries",
Brendan Eich writes
"If I were VP of Engineering in a 10,000 person company, I would want the security blanket
of the C-like syntax and a static type system for a well-known,
big-bell-curve language like AS3, C#, or Java."
It's interesting that he's
lumping ActionScript 3 with C# and Java as 'strictly typed' languages, since
ActionScript is an evolution of JavaScript, which is not strictly typed.

It's true that the documentation for ActionScript 3 uses the 'typing' notation
everywhere. Here's an example from one of the Hello World samples.

Now compare with the 'untyped' version, in which I also took the liberty in removing
the completely unneccesary semicolons. One of my pet-peeves with JavaScript:
You almost never need to use semicolons in JavaScript, but everyone does!

To prevent the compiler from complaining about the missing type information,
use the mxmlc option -compiler.warn-no-type-decl=false
when compiling. I tried playing with some options to try to get
non-typing warnings flagged as errors, instead of warnings ... and I couldn't.
The compiler would complain without the option
specified above, but always produced the .swf file in the end.

This example doesn't really do justice to the impacts of typing things. But
I think you can imagine how much more un-scannable your code is going to be
with typing information littered throughout.

What's the rationale for doing all this typing? From the
"Programming ActionScript 3.0" document:
"In ActionScript 3.0, type information is preserved at run time, and
used for a number of purposes. Flash Player 9 performs run-time type checking, improving
the system's type safety. Type information is also used to represent variables in native machine
representations, improving performance and reducing memory usage."

So typing helps with two things: 'improving type safety' and 'improving performance'.

May I suggest a comprise: use typing when it provides the convenient side-effect
of documentation, and use typing when you need to optimize something. In terms of
the documentation-style typing, I'm thinking the typing of 'fields' in an object,
and the parameters and return types of methds. In fact, if you just did that,
couldn't the compiler infer, to a large extent, the types of local variables?

Brendan also seems to be implying that corporations as a whole seem to prefer
to deal with strictly typed languages, compared to 'looser' typed languages. Implying
that ActionScript 3, and thus Flex, and thus Apollo, are all being aimed at
corporations instead of a more general audience. Assuming this, and combined with the pricing
model for tools, which I've
already blogged about
and ... yeah, you could see this as being marketed at corporations.

I'm constantly reminded of the programming model for the Palm Pilot, since
I use mine daily (but only for reading on my walks, using the fantastic
iSilo). One of the reasons for the Palm's
popularity was that approachable tools were made available to the general
public, which allowed for a flood of software programs to be released for that
platform.

If you want wild success for your programmable product, make sure your target hacking
audience is as wide as you can get.