If you’ve just started writing Actionscript 3 applications, you are probably not too familiar with most of the “best practices” for coding. Even if you’re like me, and have been developing for half your life, chances are you don’t always follow the rules. Some of us didn’t even know there were rules. Let me take that back, rules sound so constraining. Chances are, you don’t follow all of the known best practices for efficient, easy-to-digest code.

Some would argue that clean coding, and best practices won’t directly result in more money coming in for your projects. I disagree. While you can’t exactly charge a client an extra $10 an hour and say it’s because you use “best practices” and “clean code”, you can make yourself easier to work with, more efficient, and more likely to get return clients.

Let me break that last bit down for you, clean coding makes you:

• Easier to work with
  Following common best practices will enable other developers to quickly figure out, debug, and augment your code. Even if you are not working in a team environment, you can quickly earn the reputation of a spaghetti programmer (sloppy, hard to follow code). This is not something you want to happen, it can affect your chances of getting that great job or project you need.
• More efficient
  If you are spending less time trying to figure out how all that sloppy code works that you wrote weeks or even months ago, you are getting more done, in less time. This means you are being more efficient. Less time + more tasks = more money per hour!
• More likely to get clients to come back
  This is especially true if your clients ever see your code. I know a few years ago, before I started paying close attention to how well I wrote my code, clients with even minimal Actionscript experience would mention that my code seemed sporadic!

Big picture, better coding techniques = more personal worth. Now let me go over some poor coding techniques , most of which I used to practice without knowing there was a better way.

1.) Variable declarations spread throughout the program

We’ve all seen this, variables declared randomly all over the code. Every time some new variable is needed, you just create it right then, and leave the declaration were it was written. You end up with rouge variables being created all over the place.

The proper way to do this, is to keep ALL of your variables declared up at the top of your actionscript file. I also suggest ordering your variables in some sort of organized fashion.  For example, some times I will sort my variables by type:

// Array's
private var myArray1:Array;
private var myArray2:Array;

// Sprite's
private var mySprite1:Sprite;
private var mySprite2:Sprite;

// Boolean's
private var myBoolean:Boolean;
public var myBoolean:Boolean;

2.) Poor Event management

Every time you make an even listener, don’t forget you created it! As soon as the event has triggered, remove it (unless you need to keep listening for it). For example, if you have a listener on a button that goes to a new section and removes the button, remove the listener as well!

myButton.addEventListener(MouseEvent.CLICK, buttonHandler);

private function buttonHandler(e:MouseEvent):void {
    myButton.removeEventListener(MouseEvent.CLICK, buttonHandler);
    launchSection(newSection);
}

If you don’t pay attention to your event listeners, they can easily get out of hand. It’s much better to think out each event listener as you create it, and remove it when you can.

Another sorta hack you can use is weak references in your event listeners. The 5th argument in addEventListener is useWeakReference, and if you pass true, it will allow the actionscript garbage collector to grab Objects you’ve removed form the display, even if you have an event listener still on it. Without weak references & removing all of your event listeners, you could end up with a memory leak.

3.) Not removing Objects from memory

Every time you create a reference to an Object, you are taking that much memory from the computer. If you don’t remove each of the Objects you create, you can end up with another memory leak, especially if you are dynamically creating Objects.

It’s easy to think that removing an Object from the display removes it from the memory. This is far from the truth. You have to remove the Object from the display, remove all references to the Object, including event listeners, AND null out the Object.

// Create your Object
var myObject:Object = new Object();
myObject.addEventListener(CustomEvent.Event, eventHandler);
addChild(myObject);

// Later
myObject.removeEventListener(CustomEvent.Event, eventHandler);
removeChild(myObject);
myObject = null;

4.) Not Using Object Oriented Programming

The perfect way to organize your code is by using OOP. I have written an introduction to Object Oriented Programming that should get you started writing OOP.

4.) Not Keeping Your Code Clean

What is clean code? I would say its when you can read the code like a book, without the need for comments. The methods are all laid out in a somewhat linear fashion. They lead into one another, and are grouped together based on their relationships to each other.

This brings me to the next one:

4.) Using Bad Naming Conventions

Always name your variables & methods with clear intentions. Anyone should be able to understand what something does just by reading its name.  Don’t use funny names, try to make the names as informative as possible.

If your function hides all of your nav items, you could call it hideNavItems(). If your Array holds a reference to a collection of Sprites, you can name it spriteHolder.

More Resources

As you can see, there are plenty of ways you can make your code easier to understand & update. This will be beneficial not only to you, but to anyone who ever has to update or adjust your code in the future.

The biggest thing to take from this, is that by witting clean code, you increase your worth as a developer. Don’t take my word from it, give it a shot. Spend some time learning ways you can write cleaner code…

For now, you can start with some links to books & articles on the subject:

• Flex SDK Coding Conventions & Best Practices
• InsideRIA Best Practices
• Code Craft: The Practice Of Writting Excellent Code
• Essential Actionscript 3.0 by Colin Moock
• Design Patterns: Elements of Reusable Object-Oriented Software
• Actionscript 3.0 Design Patterns
• Code Complete

If you have any clean coding techniques, share them with us in the comments!