The Flash Art of War

Express Installer Utility

FlashBum — Thu, 15 May 2008 12:00:02 +0000

When doing the home page for Heavy.com we came across a “special” bug with our Flash detection script. Apparently some people who were running FireFox and Flash Player 9.0.xx+ were not able to make it through the detection script. The issue seemed to be that the browser would throw the wrong player version to JS and JS would fail to load the site (like it should do by prompting you to upgrade) but this was happening to people who had the correct version of the player. We caught this bug in QA before launching the site but here is the class I used to get around this problem.

package {
import flash.events.EventDispatcher;
import flash.system.Capabilities;

dynamic public class ExpressInstallerUtility extends EventDispatcher {

public static const INIT : String = “init”;
private static var __instance : ExpressInstallerUtility;
private var eventDispatcher : EventDispatcher;

public function ExpressInstallerUtility(enforcer : SingletonEnforcer) {
eventDispatcher = new EventDispatcher();
}

public static function get instance() : ExpressInstallerUtility {
if(ExpressInstallerUtility.__instance == null) {
ExpressInstallerUtility.__instance = new ExpressInstallerUtility(new SingletonEnforcer());
}
return ExpressInstallerUtility.__instance;
}

/**
   * Returns the full Player version from the Capabilities class.
   * @return String: MAC 9,0,115,0
   */
public function get player_version() : String {
return Capabilities.version;
}

/**
   * Returns the OS.
   * @return String: MAC
   */
public function get os() : String {
return player_version.split(” “)[0];
}

/**
   * Returns the version.
   * @return String: 9,0,115,0
   */
public function get version() : String {
return player_version.split(” “)[1];
}

/**
   * Returns version as an Array.
   * @return Array: version
   */
public function get version_array() : Array {
return version.split(“,”);
}

/**
   * Compares min version to the current player’s version.
   * @param min_version:String = "9,0,115,0"
   */
public function has_version(min_version : String) : Boolean {
var current_version : Array = version_array;
var min_version_array : Array = min_version.split(“,”);
return compare(current_version, min_version_array);
}

/**
   * Compares two versions of the player and returns if the current player is ok.
   * @param current_version: Array of the player version.
   * @param min_version: Array of the min version to test for.
   * @return Boolean: True = Good to go, False = current player is to low
   */
internal function compare(current_version : Array, min_version : Array) : Boolean {
var n1 : Number = 0;
var n2 : Number = 0;
var pad : Array = [10000000000, 100000, 10, 0];
for (var i : Number = current_version.length - 1;i >= 0; i–) {
n1 += parseInt(current_version[i]) * pad[i];
}
for (var j : Number = min_version.length - 1;j >= 0; j–) {
n2 += parseInt(min_version[j]) * pad[j];
}
return n1 >= n2;
}
}
}

class SingletonEnforcer {
}

There is nothing really special about this class. It basically adds some new functions to allow you to check for a “min” version vs the installed version. Why use this? Well the way adobe has you do a version detection is to use an AS 1 version 7 (ish) swf to do the detection. Since JS got hung up on the browsers that had the mismatched version of 9.0.xx we decided to add the check into the main app and only call the express install if the app said we had to.

So what happens is that if JS detects that you have version 9.X + it goes right into the app. Anything below is handled the old way with express install and JS. So once you are in the app I use something like this to make sure you have everything you need to run the homepage swf.

var min_version:String = “9,0,115″; // This should come in from flash vars

if(ExpressInstallerUtility.instance.has_version(min_version)) {
// Start App
}else {
// Tell JS that it needs to do the express install
ExternalInterface.call(_js_express_install, _js_parent_id);
}

So what we have here is a simple test from the ExpressInstallerUtility for the correct version from a passed in min version. If it passes, great start the app but if not we call a JS function to force an express install and have the user upgrade to the right version.

Interesting enough no to many people have run into this issue before and honestly it only happend a few times in QA but we were able to reporduce it consistantly where FireFox would have the most up to date player yet JS was unable to get the correct version from the browser. Maybe this class is something you should keep in you back pocket for a rainy day.

So what is so special about our home page that we needed to use 9.0.115? Well outside of wanting to use H.264 for our video it would appear that when you upgrade the Flash IDE it automatically forces you to build for 9.0.115. If you use the video component or net stream object and try running your swf in a lower version they don’t work or show up at all. We originally scoped it out to work for 9.0.45 but since Adobe is forcing h.264 down our throats (and that is not a bad thing) they neglected to make it clear that a simple software upgrade would lock us into a player with lower penetration then they were marketing. I wish I could stop posting about this and the ever changing Flash Player upgrades we have endured but it really leaves a bad taste in your mouth when you have to explain to you boss or client you are locked into something with no way to build to a specific player version in the Flash IDE right before launching.

Flash Player 10 - beta?

FlashBum — Thu, 15 May 2008 05:44:33 +0000

Came across this post today from flashguru.com that talks about Flash Player 10. Aparently an early release of the Flash 10 Player is available from Adobe today. Here are some really cool features I wanted to highlight from Adobe’s Site.

Visual Performance Improvements
Flash Player 10 builds on the dramatic script execution performance improvements introduced in Flash Player 9 with the new ActionScript 3.0 Virtual Machine (AVM2) by enhancing the equally important visual performance of your RIAs and rich media experiences. Leveraging the power of the GPU for blitting and compositing reduces the load on the CPU and can provide a performance boost to many graphically intense applications, resulting in more fluid, realistic and responsive user experiences.

GPU Compositing — Combining images, filters, and video in your SWF just got faster. Your video card can be used to do compositing on all raster content. Utilizing the hardware processing power of the graphics card, GPU compositing accelerates compositing calculations of bitmaps, filters, blend modes, and video overlays faster than would be performed in software on the CPU. GPU compositing is applied when specified in the HTML parameters provided appropriate graphics hardware is available. If the hardware does not provide required capability, Flash Player will fall back to the software rendering without user interaction. Hardware compositing takes advantage of the tremendous memory bandwidth and computational horsepower of the GPU, reducing the load on the CPU, and can provide a performance boost to many graphically intense applications, resulting in more fluid, realistic and responsive user experiences. Open GL 2.0 video card with GLSL capabilities required to use this feature. When in use with the beta, a green square will appear in the upper left corner when accelerated.

GPU Blitting — Paint SWFs into the browser using your video card by choosing this new HTML parameter. Your content can run faster and give you the freedom to do more. Developers can enable or disable GPU surfacing to perform hardware blitting for each SWF within a web page without having to recompile the SWF. GPU surfacing extends the hardware-scaled fullscreen view introduced in Flash Player 9 Update 3 and applies it to the browser window so that the pixels drawn to the browser go through the GPU, resulting in improved performance and reduced CPU demand, rendering video- or image-intensive applications faster.

Anti-Aliasing Engine (Saffron 3.1) — An update to the Saffron anti-aliasing text engine increases performance and quality of anti-aliased text, particularly for Asian character rendering. Support for stroke fonts reduces memory requirements.

Vector Data Type — Flash Player 10 and ActionScript 3.0 add support for a new data type called Vector that is an ECMAScript 4 proposed language addition that is similar to an Array but requires that all elements be of the same type. By having a consistent type, performance on Vectors is significantly higher than Arrays. Vectors work as a parameterized type.

For a full list look here. This is going to open up a new word of visual programming in Flash. I am really looking forward to playing around with this stuff. Luckily what I am working on at Heavy requires lots of bitmap manipulation so its good to see Adobe is really taking this stuff to the next level. Adobe, when do we get to play?

Helper Class

FlashBum — Tue, 13 May 2008 13:46:36 +0000

Sometime you need a little class to act as a Utility but still allow for for instance specific configuration. In one class your util may need to do X and in another Y but the functions and methods need to be the same for both classes. In the past I use to develop Singleton or Static utility classes but this situation breaks my design pattern. How do I handle these one off customizable utilities? I create helpers.

For me a helper class is a class instance similar to a utility with options to customize its internal values. Here is one example of a helper class I am now using in my Settings Utility.

package
{
/** (c) Copyright 2008 Heavy, Inc. All Rights Reserved.
   *
   * Original Author: Jesse Freeman
   *
   * Revisions
   * 0.1 Initial version 05-08-2008
   *
   **/

import flash.utils.Dictionary;

public class XMLTypeHelper
{

public static const STRING:String = “string”;
public static const NUMBER:String = “number”;
public static const ARRAY:String = “array”;
public static const BOOLEAN:String = “boolean”;
public static const ASSOCIATE_ARRAY:String = “associate_array”;
public static const DICTIONARY:String = “dictionary”;
public static const COLOR:String = “color”;

public var unknown_type_handler:Function = null;

public function XMLTypeHelper(){
trace(“Alert: New XMLTypeHelper has been created.”);
}

public function get_type(data:String, type:String):*{
switch(type)
{
   case STRING:
   return data.toString();
   break;
   case NUMBER:
   return Number(data);
   break;
   case ARRAY:
   var temp_array:Array = data.toString().split(“,”);
   return temp_array;
   break;
   case BOOLEAN:
   return string_to_boolean(data);
   break;
   case ASSOCIATE_ARRAY:
      return parse_complex_array(data,ASSOCIATE_ARRAY);
      break;
   case DICTIONARY:
      return parse_complex_array(data,DICTIONARY);
      break;
   case COLOR:
      return Number(data);
      break;
   default:
   if(unknown_type_handler != null)
      return unknown_type_handler(data);
   else
      return data;
   break;
}
}

public function parse_complex_array(data:String, return_type:String,data_delimiter:String = “,” ,prop_delimiter:String = “:”):*{

var data_container:*;

// Switch Statement
switch (return_type){

case ASSOCIATE_ARRAY:
data_container = new Array();
break;
case DICTIONARY:
data_container = new Dictionary();
break;
}

var list:Array = data.split(data_delimiter);
var total:Number = list.length

for (var i : Number = 0; i < total; i++) {
var prop:Array = list[i].split(prop_delimiter);
data_container[prop[0]] = prop[1];
}

return data_container;

}

/**
*
*/
public function string_to_boolean(value:String):Boolean{
return (value == “true”) ? true : false;
}

}
}

So this is a really simple class. It basically converts values read in from an XML file and converts them into typed valued base on the attribute type. Nothing really special here, in fact I was using something similar to this set of functions in my AS 3 Setting Utility. So why break this out into is own class?

Part of writing truly OOP code is being able to break out reusable functions into other classes. Also now with all this code taken out of the setting utility I can keep adding to it and have the logic in one self contained place outside of the class that needs it. I can also configure this class’s instance based on the situation it is needed in.

Now there is a special property called public var unknown_type_handler:Function = null;. This allows you to map a custom function to be called when the util doesn’t know what the data’s type should be. Here is an example of how to use it.

var typer = new XMLTypeHelper();
typer.unknown_type_handler = special_type_converter;

. . .

internal function special_type_converter(data:*):*{
switch(data.@type.toString()){
case “Option A”:
      return null // Handle Option A Here;
      break;
   case “Option B”:
      return null // Handle Option B Here;
      break;
}
}

One last thing I am proud of in this class is the converter to Associated Array and Dictionary. When you supply xml that is comma delimited with colons dividing prop name and value, this class will give you back a parsed Array or Dictionary. Here is an example of what the data node would look like:

type=“dictionary”>hello:world,this_is:great>

This class is still under the microscope at Heavy so in it’s final state I expect it to be a little cleaner, and less buggy (if any exist let me know). I’ll be posting more of my Helper Classes as soon as I get stable. So far I have several that range from creating 9 slices from bitmaps to class finders and a few others. Hope you enjoy!

Oh, and make sure you visit Heavy.com to see more of my work and click on a few ads to keep the lights on in my office.

Nice Flex Site

FlashBum — Sun, 11 May 2008 17:00:03 +0000

I have not been a big fan of Flex sites. For the most part they all look alike and the component framework lets developers get away with creating something and not needed to have a single design bone in their body. My opinion changed after I found this site grooveshark.com. This link goes to the lite player but the main site is worth a look over too.

Here is a screen of the app.

I have finally been inspired to break out a Flex 3 project and try my hand at it. To bad I still can’t get over the ~200k+ of added wight the Flex Framework adds to your app. Sorry Adobe, letting the player cache the framework on people’s computer still doesn’t make it better.

On a side note, after showing the site to Myles he pointed me out to a few resources that have “skined” UI components for Flex. This one from Yahoo looks like what Grooveshark based their design off of. Here is another link to some more great Flex skins.

Letter Particle Generator

FlashBum — Sat, 10 May 2008 16:33:30 +0000

A little while back a friend of mine asked me to help him put the finishing touches on a jewelry site he was having built. They wanted to take the existing AS 2 site and connect it to my FlashBaker Admin panel and clean up a few things as well. Since I detest AS 2 at this point I felt it would be better to just port the entire site over to AS 3. While I did that, I overhauled this Letter Particle Effect that was being used on the site. I thought I would release the source code to the particle system and hopefully drum up some traffic to his site TypeOfLove.com.

So you can see the full effect on typeoflove.com. Warning that the site is still alittle buggy. I had to port the entire thing over in a few days so it is still missing that “FlashBum” polish I normally put into a site. Here is an image of the effect.

So I thought for this round instead of posting all 6 classes of code I let you download the source files and let you play around with it on your own. For those interested, I will highlight a few of the important parts of the code and discuss a little about this partical system and what you can do to customize it. Here is a sample of the demo swf:

Lets start with how you create a “generator”. In this example there is one class (controller) that manages instances of particles (Letters and Dust) and has the power to start and stop them. In the source file, if you look in the FLA you will see this code:

import com.tol.letters.*;

var config:GeneratorConfig = new GeneratorConfig();
config.width = 400;
config.height = 300;
config.letters = new Array(“a”, “b”, “c”, “d”, “e”, “f”, “g”, “h”, “i”, “j”, “k”, “l”, “m”, “n”, “o”, “p”, “q”, “r”, “s”, “t”, “u”, “v”, “w”, “x”, “y”, “z”);
config.max_particles = 25;

var gen:Generator = new Generator(config);
addChild(gen);

gen.start();

As you can see the generator needs a config class. Some of the important properties to look at are the width, height, and charactes. The characters array allows you to create particals out of any text character. This is the display of the paticals. There are two type of particals, Letters and Dust. A letter partical is the base partical class. It generates a display randomly from the list of characters. Once the display is set, it then begins to move itself based on a predetruming set of variables and random multipliers. Lets look at this a little further.

Letters need to do the following things:

Move from x0 (Start) to x1 (End).
When it reaches x1 it needs to restart back at x0.
It needs to be a random size, alpha, and rotation.
As it move its needs to not only rotate but also grow or shrink in size and move in a curve. (letters are designed to move like leafs in the wind.

Dust is an extension of the letter particle. It has the same kind of display and uses the same character list. The only difference is the following:

Dust is always a fixed size and rotation.
Dust moves from straight and has no curve or arc.
Dust moves a lot faster then Letters, it is more like a bullet across the screen.

So all the particals have a custom config file that has specal setting for each type of partical. This allows you to customize the speed, rotation, character of each and let the class handle any custom logic needed to run. The Generator is unaware of the specifics of the partical, it just needs to know how to turn it on and off. And so the partical engine is a nice modular collection of code following some basic (hacked in) OOP ideas.

Here is a sample of the 3 main functions to move, rotate and scale the particals

/**
* Moves partical based on a its speed.
*/
protected function move():void
{

}

/**
   * Increments the partical’s rotation.
   */
protected function rotate(value:Number):void
{
rotation += value;
}

/**
   * Calculates size of the partical
   */
protected function size():void
{
if (_display.scaleX < 100){
_display.scaleX += .03;
_display.scaleY += .02;
}else{
_display.scaleX -= .02;
_display.scaleY -= .01;
}
}

What is next? If this was something I had built from the ground up I would have broken things down a little further. It is always better to type classes to a interface or abstract class. Here I probably would have done both. There should be an IPartical interface along with a base partical class I would probably call AbstractPartical. The generator would have its particals types to the Interface, and the Letters and Dust would extend off of the AbstractPartical Class. Things like this are overkill in a small “static” website environment with predefined rules but if I wanted to change this up or reuse it in another project the extra effort to use Abstarct Classes and Interface would really pay off.

Also the way I handle the movement loop blows. I am not a big fan of enterframe loops at this stage of the game but when you need to get something up and running ASAP they are a good cop out. It is always important to weigh out the cost of what you are doing verses the time you have to do it in. I noticed a slight performance hit on the motion and I think that I could have done a better job of making things move faster and require less processor.

I find particle systems really interesting and fun to play with. Its amazing how you can take something so simple and get it to yield such complicated visual effects. The master of Flash Particals in my opinion is Seb Lee-Delisle¹ over at Plug-In Media. The man is a mad genius and I had the please of not only being at his presentation at FlashBelt last year but also got in a few drinks/karaoke songs². Take a look at his blog if you want to learn more about some of the cool effects you can achieve in Flash with particles.

Self proclaimed Flash ambassador for Brighton [↩]
I am in the middle in the hat and Seb is on my left (Right of the photo) in green along with everyone else from the conference [↩]

flashlog.txt for trace();

FlashBum — Sat, 03 May 2008 21:43:01 +0000

In this post I talked about how I see trace comments in my console (on Mac OS X) and a few people were interested in how I set that up. Here is some info to help you out.

Before you do anything make sure you install the Debug Player for Flash 9.0.xxx (what ever the version is this week). You will see the link for it down the page a little under Adobe Flash Player 9 — Debugger Versions. If you do not have this installed you will not be able get any of this to work. Here is a screen shot to show you how you will know if you the Debug Player installed.

When you right click on any Flash SWF in your browser you should see the words “debugger” in the context menu.

Once I had the Debug Player installed, I set all this up with Textmate and the excellent bundle from here. Here are a few screens from the debug the options you need to click on to get it working.

This is the bundle I am using, you can download it here

These are the debug options. I clicked on all of them starting with “Format fsch…”, “Install mm.cfg”, then “Opne flashlog.txt…”

Also you should check out this really great post from http://blog.flexexamples.com. It does an excelent job of walking you through how to manually set this up on a Mac and a PC.

Here is a screen from my Mac Console window reading off of the flashlog.txt file. Its not at fast as the Flash IDE output window but for day to day development it is a life saver.

Nice, look at all those cool traces!

One last thing, I found this link on google by searching for “mm.cfg” and it talks about trouble shooting.

Random Coolness

FlashBum — Thu, 01 May 2008 15:02:53 +0000

I use the Flash Debug Player and have set it up to output all traces out to the console on the mac to help with all my debugging. This is great to see traces outside of the Flash IDE without the need of any extra software or custom built solution. I tend to leave it open a lot and when I visit other Flash sites I wind up seeing any traces that had not been removed. Well this morning while I was just surfing the web I went back to my console and saw this:

Showplayer initializing…
__—__
_- _–______
__–( / \)XXXXXXXXXXXXX_
–XXX( O O )XXXXXXXXXXXXXXX-
/XXX( U ) XXXXXXX\
/XXXXX( )–_ XXXXXXXXXXX\
/XXXXX/ ( O ) XXXXXX \XXXX\
XXXXX/ / XXXXXX \_ \XXXX—-
XXXXXX__/ XXXXXX \_—- -
—___ XXX__/ XXXXXX \_ —
– –__/ ___/\ XXXXXX / ___—=
-_ ___/ XXXXXX ‘— XXXXXX
–\XXX\XXXXXX /XXXXX
\XXXXXXXX /XXXXX/
\XXXXX _/XXXXX/
\XXXX–__/ __– XXXX/
–XXXXXXX————— XXXXX–
\XXXXXXXXXXXXXXXXXXXXXXX-
–XXXXXXXXXXXXXXXXXX-
render 115

Unfortunately I don’t remember what I was looking at but who ever the developer that added this into the traces is my hero! Got me thinking of how to keep traces in some of my apps to add notes to other developers as a running joke. Anyone else do stuff like this?

Useless Getters/Setters

FlashBum — Sat, 26 Apr 2008 14:18:51 +0000

Part of building my new Framework revolves around optimization (Code, Size, and Speed). One of the quickest optimizations I have done is removing all the useless getters and setters and instead replace them with public vars.

I use to be a big believer in always using a getter/setter to access class variables. In my mind it kept the class protected from other classes and allowed me to bake in additional logic into the getters/setters to validate the data passed into them. Well when I went back over my code and saw I had dozens of these things that simply exposed a private variable and did little else I realized how much of a wast that really was.

For a few years I never used a single public variable, now I find myself going back and once I remove the getters and setters, I can simply turn the private variables into a public one and the code rarely needs any more re factoring. Lets see an example:

This is my AS 3 Config class I posted a little while ago here.

package com.jessefreeman.configs {
import flash.events.EventDispatcher;

/**
   * @author jessefreeman
   * Use this as a base class for any configuration objects. It has built in support for a few basic values but should be extended to meet the needs of your application.
   */
public class AbstractConfig extends EventDispatcher {

/** Some Default variables **/
protected var _name : String;
protected var _x : Number;
protected var _y : Number;
protected var _width : Number;
protected var _height : Number;
protected var _alpha : Number;
protected var _rotation : Number;
protected var _debug : Boolean;

/**
   * Get function for _name.
   * @return _name : String
   */
public function get name () : String {
return _name;
}

/**
   * Set function for _name.
   * @param value : String
   */
public function set name (value : String):void {
_name = value;
}

/**
   * Get function for _x.
   * @return _x : Number
   */
public function get x () : Number {
return _x;
}

/**
   * Set function for _x.
   * @param value : Number
   */
public function set x (value : Number):void {
_x = value;
}

/**
   * Get function for _y.
   * @return _y : Number
   */
public function get y () : Number {
return _y;
}

/**
   * Set function for _y.
   * @param value : Number
   */
public function set y (value : Number):void {
_y = value;
}

/**
   * Get function for _width.
   * @return _width : Number
   */
public function get width () : Number {
return _width;
}

/**
   * Set function for _width.
   * @param value : Number
   */
public function set width (value : Number):void {
_width = value;
}

/**
   * Get function for _height.
   * @return _height : Number
   */
public function get height () : Number {
return _height;
}

/**
   * Set function for _height.
   * @param value : Number
   */
public function set height (value : Number):void {
_height = value;
}

/**
   * Get function for _alpha.
   * @return _alpha : Number
   */
public function get alpha () : Number {
return _alpha;
}

/**
   * Set function for _alpha.
   * @param value : Number
   */
public function set alpha (value : Number):void {
_alpha = value;
}

/**
   * Get function for _rotation.
   * @return _rotation : Number
   */
public function get rotation () : Number {
return _rotation;
}

/**
   * Set function for _rotation.
   * @param value : Number
   */
public function set rotation (value : Number):void {
_rotation = value;
}

/**
   * Get function for _debug.
   * @return _debug : Boolean
   */
public function get debug (): Boolean {
return _debug;
}

/**
   * Set function for _debug.
   * @param value : Boolean
   */
public function set debug (value: Boolean):void {
_debug = value;
}

/**
   * Constructor
   */
public function AbstractConfig() {
//Add custom logic here if needed
}

}
}

vs

This is the config class I am now using:

package com.jessefreeman.configs {

public class AbstractConfig {

public var name : String = “untitled”;
public var x : Number = 0;
public var y : Number = 0;
public var width : Number = 0;
public var height : Number = 0;
public var alpha : Number = 1;
public var rotation : Number = 0;
public var debug : Boolean = false;
public var base_url:String = “/”;

/**
* Constructor
*/
public function AbstractConfig() {
// Does nothing
}
}
}

Big difference right? Sometimes the hardest part of optimizing is knowing where and when to “edit” your code. Here is a link to a really good article about the speeds of accessing variables from classes and how they range from getters/setters, sealed, dynamic and proxy classes.

Google Analytics Bug?

FlashBum — Thu, 24 Apr 2008 06:12:45 +0000

There has got to be something wrong with this, how can 74% of traffic be coming from the 9.0 player? There is no such thing as a flat 9.0 Player, take a look:

This is a screen shot from showing the breakdown of FlashPlayer versions:

Click on image to see full stats

I would say ok, maybe this has something to do with a combination of all the Flash 9.x.xxx Players but even if you add them up they don’t come close to the total for “Flash Player 9″. So how can I accurately gauge the visitor’s player version with this apparent oversight in tracking?

I also would like to take this rant to ask Adobe to please stop releasing incremental builds of the Flash Player. Player 9.0.115 was tough pill to swallow but damn, now I have to look out for 9.0.124? At what point did creating Flash apps become like CSS on different browsers. We are now building for specific versions of the player and its fucking lots of people up! When will the madness end?

FlexBuilder 3 vs FDT 3

FlashBum — Thu, 24 Apr 2008 05:46:51 +0000

After 3 years I have finally given up on FDT.

For all the amazing code hinting I would get out of FDT and real time error checking I just couldn’t live with the speed and memory requirements any longer. I am using a 2.6 ghz MacBook Pro with 4 gigs of ram. There is no reason why I should see a beach ball while I type, or when I open an application, or even when the workspace is constantly rebuilding itself. For all the stuff I love in FDT the final death blow was a recent bug that popped up with my FDT + Flex SDK building combo. I keep getting a Java error or Eclipse BeachBalls and crashes. This is recent, but is only the icing on a cake of crap I put up with because I was basically to lazy to type out my own variables and import packages.

So what am I using now? I am 90% into FlexBuilder. I swore I would never make the plunge but after a week of developing I feel just as productive and more in touch with the core language again. I am trying to not rely so much on the code completion unless I really need it.

I also tried TextMate but found it to be way to basic. I admit I should be using an editor that is even more light weight with no code completion but while building my new frame work, when lots of classes are in flux and are being moved around, TextMate just couldn’t cut it. Refactoring has always been one of Eclipse’s strong points. Plus with TextMates lack of a “visual” SVN/CVS repository manager, I feel compelled to stay within the Eclipse system.

So what is so good about FlexBuilder? Well here are a few of my observations:

Its fast. I mean damn fast. I always thought Eclipse was the underlining problem with FDT but I was so wrong. When you use the standalone FlexBuilder it is super fast. The key to this speed is that no validation is done until you hit save. Then you get error checking with a special twist. Its seems to be incrementally compiling with every save so when you compile, it instantly opens.
Support for code completion. I still get a basic level of code completion. Good for jogging my memory but not as much of a crutch as FDT. I feel like the system guides me now as opposed to me solely relying on the code completion, variable generation, and class templates.
Plugin support. I still get to add in some of my favorite plugins such as XMLBuddy and SVN.
And did I mention its fast. I didn’t even have to allocate more memory to FlexBuilder. It ran fine in default and my laptop’s fan wasn’t constantly running.
I still get to use my SVN/CVS tools such as repository exploring, compare, replace, and one hell of a file merge.
Re-factoring is easier. FDT still holds the title for easy re-factoring and since FlexBuilder was all about “re-factoring” I thought I was in for a treat. It does work when renaming classes and I like the advanced tab that shows you all the classes that will be changed. Also the Find all is a big help as well.
Workspace auto refreshes. I can’t tell you how much I hate that FDT’s workspace is always out of sync. From committing files to adding new ones on the files system, FlexBuilder keeps up. I don’t think I have ever touched the refresh option in the project. In FDT every time I wanted to do something file related I hit that refresh just to be safe.

Unfortunately life isn’t always roses in the FlexBuilder. Adobe still has a lot of work to do to bring it up to speed with FDT and help compete:

WTF, no templates? The most basic core part of FDT was templates, they made everything so much faster and consistent. No luck, although on a mac I have a little helper to “substitute” those templates. I have been using TextExpander but its not perfect and I am not happy.
Something is missing, its still a pain in the ass to set up projects. Right now I am using the AS 3 Project Template instead of the Flex Project. Why doesn’t the AS 3 project come with a default src folder like the Flex one. Small oversight but its one extra step I need to do in the project setup to get it configured the way I need it.
Linked libraries are a pain to set up. why do I have to jump through so many hoops for a simple linked library to run. Again I thought this was an Eclipse issue but it turns out FlexBuilder sets them up the same exact way FDT does but in FlexBuilder I have to go through 4 more steps to do it.
bin-debug folder sucks. Maybe I just don’t understand yet but why is that the default build path when I can’t add/edit files in there because its considered a “derived” folder. I like that the wrapper HTML is auto generated but I don’t see where I can set up all my other files to be like that such as my config XMLs, Graphics, and other swfs. Bad workflow, and also the directory is ignored in SVN so when you add stuff to it, it doesn’t committed. Again something I may not understand just yet.

So it looks like there is more Bad then Good, why do I still like it? Maybe its the old girlfriend¹ you just can’t get over. Flash and me have always had this love hate relationship. I feel this need to have some pain in my development in order to feel that I have built something monumental. I don’t mind a little pain as long as its over quickly. I would gladly give up FDT to just have an editor that was a few seconds faster. Speed is everything; code hinting + auto compile + low memory = good tool. The other stuff is fluff anyways and if the developers at Adobe put a little extra effort into the next version, we should see all of the stuff that is missing now. Its not like it can’t be done, I have seen everything I want in FDT.

Now if only the guys who make FDT could give me a setting to make the validator only kick in after I save, and not make it real time, I would gladly shell out the $600+ again for the plugin. The jackpot would probably be a standalone FDT editor based on eclipse without all the Java Editor BS. Something light weight and portable/standalone like FlexBuilder.

Competition is good. Adobe needs to be reminded that they are not the only game in town. Also, Flash CS 3 is now almost obsolete for me. I have no use for the IDE. I can’t tell you how happy I am to be done with that piece of crap. You would think after 6+ years they could have made a better IDE. Sorry, low blow to Adobe (Macromedia) but I do not have a single fond memory of using the IDE. I could write a book on how much using Flash 4-MX + 8 + CS 3 sucked.

Wayne and Garth’s hobbies include … avoiding Wayne’s ex-girlfriend Stacy, (whom he refers to as a “psycho hose beast”)… - Wikipedia [↩]