I decided to create a useful one page summary that can be revisited every time you forget the different types of modifiers available in ActionScript 3.0.

To begin let’s split the modifiers into two groups;

• Access modifier – is a modifier that changes the visibility of a class or its members.
• AS 3.0 Modifiers - used to modify declarations of types and type members in AS.

Access Modifiers

AS 3.0 Modifiers

* Keyword is not available

As default I highly recommend you to declare your objects as private unless you need to let other class access the object. The goal is to keep your object as abstracted as possible; making your code as loosely coupled to other objects, which will increase the re-usability of the objects.

When developing API’s in Action Script we design and choose from different modifiers, however when the wrong modifier is used the object can be misused and the objects become coupled to other objects.

Here’s my wish list for AS 4.0;

• Action Script supports the abstract modifier.
• Action Script support for static classes to insure they are not being created by creating an instance reference.
• Action Script allow the creation of Private class constructors.

There are many scripts out there to add these modifiers but many seem like a hack than an elegant solution. They basically help you enforce how the modifiers should act.
The only one that I see as a good solution, and not as somewhat of a hack is for creating Abstract methods and classes, here’s an example of how to create and implement;

package com.utils
{
    import flash.errors.IllegalOperationError;
    public class AbstractClass
    {
		public function AbstractClass(self:MyAbstractClass)
    	{
    		if(self != this)
    		{
    			throw new IllegalOperationError(”Abstract class did not receive reference to self. MyAbstractClass cannot be instantiated directly.”);
    		}
    	}

		public function method(param:String):void
    	{
    		throw new IllegalOperationError(”abstract function must be overriden”);
    	}
    }
}

And here’s how you would implement the class;

package com
{
    public class MyImplementClass extends AbstractClass
    {
	    public function MyImplementClass()
    	{
    		super(this);
    	}

		public override function method():void
    	{
    		trace("Method");
    	}
    }
}

dropShadowColor : “0xFFFFFF”;
dropShadowEnabled : “false”;
border-thickness-bottom : 0;
border-thickness-top : 0;
border-thickness-left : 0;
border-thickness-right : 0;

Or directly on the component such as;

borderColor=”white” borderThickness=”0″

You just can’t get the fu#$%$ borders off! The reason is that flex assign a border skin: borderSkin=”mx.skins.halo.HaloBorder” which will always going to leave a line on the top corner.

The solution is actually simple; create a skin and don’t draw anything leaving the skin borders empty, that will remove the borders, shadows etc;

package com.skins
{
import mx.skins.Border;

public class TextInputBorderlessSkin extends Border
{
override protected function updateDisplayList(w:Number, h:Number):void
{
super.updateDisplayList(w, h);
}
}
}

Now you can assign the skin in your CSS to your component text input;



.BorderlessTextInput {
    border-skin: ClassReference(”com.skins.TextInputBorderlessSkin”);
}

Play around with skins in Flex, you’ll have a lot of fun!

Experience the application here:
http://elromdesign.com/blog/Flex/Jobs/

The Mashup allows you to search for Adobe Flex Developers Jobs based on your Zip code. In addition, you can SMS a job posting to your cell phone. I used two Application Programming Interfaces (APIs), a web service and skin styling.Tomorrow’s one hour presentation will focus on describing what the buzz around Mashup is all about, how to build your own Mashup in Flex and helpful tools and tips to make your life easy.

If you live in the New York area, sign in at New York Flex Group [http://NYFlex.org] and stop by tomorrow! We will have a lot of fun!

1. When you need in-memory data structures.
2. When you need a pair of key-value data structure.
3. When you need to Increase performance.

Flex and Action Script provides the “IList” interface that is implemented by the Array and ArrayCollection. Using array is a great choice when you need to associate an object with an ID, but if you have scenarios where you want to copy a large database structure to the memory or have a key-values pairs you will have to iteration through the array in order to do a lookup.
The API I developed is called “HashMapCollection” and it is using naming conventions that are very similar to the “ListCollectionView”.

The API is also implementing the change events classes, so you will be able to start using the API right away with much similarity to the “IList” methods.

Let’s take an example. Say we have list of contacts and phone numbers and we need to store them in the memory, the list was given to us through the SQL database and it has about 10,000 contacts.

Using Array or ArrayCollection will force us to loop through the list until we find the name we are looking for and then get the phone number, that process will put a large expense on Flash player and will basically look as if the program is stuck, since action script is a single thread programming language, which means that the program cannot split itself into more than one simultaneously tasks.

The HashMapCollection doesn’t need to loop it’s basically using the following code to find the value:

map[key] = value;

I am giving a list of contacts, as an example, but let me make it clear that the HashMapCollection is flexible to use any type of key-value such as;

• Name-UIComponents
• Name-Object
• Name-Array

Below you can find a use-case example of creating a data structure and modifying the data;


private function map():void {

var map:IMap = new HashMapCollection();
map.addEventListener(CollectionEvent.COLLECTION_CHANGE, handler);

map.addItem(”John”, “212-452-8086″);
map.addItem(”James”, “718-345-3455″);
map.addItem(”Micheal”, “917-782-8822″);
map.addItem(”Ron”, “212-426-8855″);
map.addItem(”Mike”, “212-255-2436″);
map.addItem(”Jenny”, “718-344-2433″);
map.addItem(”Jack”, “917-222-4352″);
map.addItem(”Riki”, “981-222-1122″);
trace(”\nAll items: “+map.toString()+”\n”);

trace(”containsKey Jack? “+map.containsKey(”Jack”));
trace(”containsValue 718-344-2433? “+map.containsValue(”718-344-2433″));
trace(”getItemKey 718-344-2433: “+map.getItemKey(”718-344-2433″));
trace(”getItemValue Jenny: “+map.getItemValue(”Jenny”));

map.removeItemAt(”Riki”);
trace(”Remove Riki.”);
trace(”getItemValue Riki: “+map.getItemValue(”Riki”));
trace(”Comapre: “+map.compare(”Ron”, “212-426-8855″));

map.removeAll();
trace(”\nAll items: “+map.toString()+”\n”);

}

private function handler(event:CollectionEvent):void
{
trace(”Event: “+event.kind);
}

All of this is great, but let me actually prove to you that you gain performance. I created a small Flex application that creates two data structures; ArrayCollection and HashMapCollection. Watch the memory monitor and see how Flash Player actaully stopped while it loops and looks for the key in the ArrayCollection. On the other hand the HashMap doesn’t add any expense on the Flash player.

All source code contained in this API has been published under the MIT licence and is protected as stated therein.

To see the example and download source code (via right click):
http://elromdesign.com/blog/Flex/API/HashMapCollection/

To view the ASDOC of all the API:
http://elromdesign.com/blog/Flex/API/asdoc/

Have fun!

1. In many cases, using singleton is an anti-pattern;
2. The singleton may be considered as an anti Action Script, since Action Script 3.0 doesn’t support private or protected constructor;
3. With programming, it is usually not recommended to

use global objects, since it is hard to test them and the developer has to make assumptions regarding the application and how they will be used.

The main source of the problems is that using the singleton pattern makes the classes tightly coupled instead of loosely coupled, meaning that you can only test a few classes together rather than each of the classes at a time, as you should.

Before I go into a discussion on when is it a good idea to use the singleton pattern, I think it’s a good idea to show how the singleton is used in Action Script 3.0.

What is the singleton pattern?
The singleton pattern is used to restrict instantiation of a class to one object. The pattern keeps a private constructor to insure that the class was created only once.

Singleton in Action Script 3.0:
Action script does not support the option to declare constructor as private or protected inside of a package, which causes a design pattern problem, since any option you choose will be considered workaround or a “hack”.

One popular option is to use the inner classes, meaning creating another class inside of the package to behave as the private constructor, such as in the example below:

package {

	public class Manager
	{
		/**
		 * var to be used by the singleton pattern to return the instance of the class.
		 */
		private static var manager : Manager;

		/**
		 * Internal constructor. Should not be called from outside this class.
		 *
		 * @param enforcer	Enforce the creation of one class only.
		 *
		 */

		public function Manager(enforcer:AccessRestriction)
		{
			// TODO: throw exception
			if ( enforcer == null )
			{
				throw new Error("Manager error enforcer input param is undefined" );
			}
		}

		/**
		 * Method function to retrieve instance of the class
		 *
		 * @return The same instance of the class
		 *
		 */
		public static function getInstance() : Manager
		{
			if( manager == null )
				manager = new Manager(new AccessRestriction());

			return manager
		}
	}
}

class AccessRestriction {}

To view the source code as text file click here.

So when should you use the singleton design pattern?
Here’s a singleton recommended check list:

1. Singleton should be used in cases where only one object is needed to coordinate actions and/or events across the application;
2. The application will always use the object in the same way;
3. It doesn’t really matter to the client what’s going on in the rest of the application, meaning that the singleton object is independent.

If you can confirm the check list, than it’s a good candidate to use the singleton pattern.

Have fun designing!

Flex is a single thread programming language which means that the program cannot split itself into more than one simultaneously tasks and it causes flex to slow down, especially when the cost of initializing a class is high. Object pooling can be used to manage object caching and boost performance.

A real life example is a book case. You have a case full of books and you decide to read one of the books. While you use the book you may stained a page by a coffee and changed the look of the book. After you are done using the book you return the book to the book case for later usage.

Object pooling works the same way, the object pooling class is singleton to insure you are not pulling more than one reusable object at a time. At any given time you pick a reusable object, the object is being removed from the collection so the client can change it and place it back for future usage.

The Flex API I developed is based on creating a usable collection of objects, the objects can be any component such as Flex Sprite or Canvas, array, class or anything you want it to be.

The object pooling can boost performance; especially in cases where the resources used to initializing a class instance are high, the number of times the class will be usage is often, and the number of instantiations in use at any single time is low.

All source code contained in this API has been published under the MIT licence and is protected as stated therein.

To see an example and download source code:
http://elromdesign.com/blog/Flex/API/ObjectPoolManager/

To view the ASDOC of all the API:
http://elromdesign.com/blog/Flex/API/asdoc/

CursorManager class is useful for replacing the cursor with a custom cursor or for creating a busy cursor, but what do you do when you want to create a set of custom cursors? You may also be interested in building few sets of custom cursors to be used in different part of the application and keep track of them in one centralized location.
For example you want to create couple of sets of cursors. One of them will be a custom image, the cursor will change on mouse down and mouse up events and the cursor will have a custom busy image. That set will be used in one component and another set will be used in a different component.

Custom cursor API is based on creating custom sets of cursors for usage in an application. You create a concrete class and set all the images, swf or sprite objects you want to assign to that set and the cursor will change according to how you set it in the concrete class.

All source code contained in this API has been published under the MIT licence and is protected as stated therein.

To see an example and download source code:
http://elromdesign.com/blog/Flex/API/Cursor/

To view the ASDOC of the API:
http://elromdesign.com/blog/Flex/API/asdoc/

The issue gets even worse once you need to submit few SQL commands for one operation. For example you have a form and once that form submit the client request to sign to a newsletter so you would need two SQL statements.

I created an elegant solution to that problem, utilizing the Abstract Method design pattern. The “SQLStatements Manager” (Flex SQL statements API) will let you create different CRUD (Create, Read, Update and Delete) statements for each form and you have one place where all your SQL commands are located so once it’s time to change them or update your database design, you don’t have to go through your entire application looking for all these SQL statements.

Once you have the SQL statement you can submit them to the database in order to process. I may give an example of implementation of the API using ColdFusion and Cairngorm.

To see an example and download source code:
http://elromdesign.com/blog/Flex/API/SQLStatementsManager/

To view the ASDOC of the API:
http://elromdesign.com/blog/Flex/API/asdoc/

This API will be in a new Flex 3.0 book I am writing called “Developing Enterprise Architect Applications.” click here to read more and pre-order.

All source code contained on this page has been published under the MIT license and is protected as stated therein.

This book makes advanced Flex 3 concepts and techniques easy. Ajax, RIA, Web 2.0, mashups, mobile, the most sophisticated Web tools and the coolest interactive Web applications are all covered with practical, visually-oriented recipes.

* Practical, how-to approach for advanced results.
* Leverage the tools you know, Java, PHP, Python, Ruby, in combination with Flex.
* Build high-performance Web applications with interactivity that really engages your users

To read more about the book click here.

Additionally, I am in the process of writing the following book:

Advanced Flex 3.0 - Developing Enterprise Architect Applications.
The book will be published in late 2008. The book will cover the subject of developing an Enterprise Level Flex Applications from planning to designing and finally testing. It is intended for the experienced Flex developer wishing to expand his/her knowledge and expertise. Developing a large scale Flex application is different than developing a small application and although there is a lot of information, there is not any one resource that covers it all. This book will cover all the best practices and give you the tools you need to develop such a large scale Flex application.

In the next few months I will be giving away some of the API’s that will be part of the book. To learn more about the book and signup for the pre-order list click here.

This API will be in a new Flex 3.0 book I am writing called “Developing Enterprise Architect Applications.” click here to read more and pre-order.

All source code contained on this page has been published under the MIT licence and is protected as stated therein.

To see an example and download source code:
http://elromdesign.com/blog/Flex/API/AutoSuggest/

To view the ASDOC of the API:
http://elromdesign.com/blog/Flex/API/asdoc/