One of the most common questions that seem to be still floating around the web development community is “Which program should I use for Flash development?” That question is best answered based on the goals of your project.

The Question

The first question to be asked to help answer the question of which program should be used is simple. Is this project for a full flash website or is this project for a web based application? If it is for a web based application then the answer is to use Flex. Now if the project is for a full flash website that does not necessarily disqualify Flex from use. If the website still requires a medium to large amount of functionality then Flex is still probably the best program to use.

Pros vs. Cons

If the questions in the previous paragraph are not enough to end the argument of which program to use then maybe you can better decide based on some outlined pros and cons of each program. Lets start by looking at the pros and cons of using Flex.

Flex Pros

• More efficient for programming oriented projects

• More efficient for fast user interface layout and skinning

• Fluid layout abilities are built in and on by default

• Ability to use simple and complex assets from a compiled SWF

• For programmers, the environment is more optimized with nice code hinting and XML based component definition.

• Built in support for i18 internationalization and runtime localization

• Visual layout editor for easier user interface design

• Program built on the Eclipse platform which allows further extension of the IDE

• ActionScript framework can be cached by a browser’s flash player for later use among multiple sites

• Compile time is faster since the entire SWF does not have to be recompiled for every change

• Build in support for modular based application architecture

Flex Cons

• No timeline available for drawing objects and animations (solved by using SWF based assets)

• Program built on the Eclipse platform which can sometimes (but not often) cause system performance issues such as CPU load

• More programmer oriented IDE instead of designer oriented

• Compiled SWF files can be at least 300 KB when the framework isn’t exported as Runtime Shared Libraries

Flash Pros

• More designer efficient for drawing and animation

• Program usability is higher for non-programming related tasks

• Compiled SWF file sizes are very optimized since they do not have to include an extra ActionScript library

Flash Cons

• Poor support for ActionScript programming such as no custom code hinting, only the built in libraries

• Compiler not as fast since it has to recompile the entire SWF for any changes

• No built in support for modular based application architecture

The Conclusion

There are far more pros and cons that can be listed for each program but I just wanted to outline a lot of the important ones that affect my decisions on every Flash based project I do. In my experience I almost always use Flex as the primary program for website and application development. This is because I am a full time programmer so Flex better suits my needs when trying to product a website and/or application as quickly and efficiently as possible.

I am overly tired of dealing with heavy site customizations that must take place within these “frameworks” such as Wordpress, Drupal, or Joomla. It is very depressing for me because I have being forced to write bad code which is exactly what has to be done to make a “successful” module or reusable feature for any of these three frameworks. (and many others I’m sure)

My idea of what a good site development framework would be is one that is built on good programming practices and efficiently uses the appropriate design patterns. Using the MVC design pattern would be a must. It has proven it’s success in aiding in the organization of web application code. Needless to say, I have yet to see any of these content management systems properly implement that. I think that a framework that supported drop in module features is always useful for quick deployment and expansion but what happens when you need to customize one of those modules and its built with nothing but spaghetti code?

The majority of the cases that I have come up on thus far when needing to customize a Wordpress installation I usually have to turn to finding someone’s pre-built plugin and further customizing it how it is needed. What my findings have been on the majority of these customizations is that if I would have just built it from scratch from the start, I would have either spent the same amount of time or a little less and had a much higher quality product in the end. The reality is though, some of the things I have to do to make a plugin work in Wordpress is not what I would call quality work when all said and done so it’s really not that valuable to me in the end. I would much prefer that if I were going to write a custom module or plugin for an application, I would rather do it in a well structured development environment that follows good practices for enterprise level development. I don’t think any good programmer would argue that you can’t find that kind of structure in Wordpress, Drupal, Joomla, or any other framework like thoses.

</rant>

The syntax for using this settings manager is really simple as well. It can be initialized in the onApplicationStart method of your ColdFusion application’s Application.cfc file using the code below.

<cfset path = replace(getDirectoryFromPath(getCurrentTemplatePath()), ‘\’, ‘/’, ‘all’)>
<cfset application.settings = createObject(’component’, ‘com.logicalchaostheory.settings.SettingsManager’).init(path)>

Just add the code above and extract the contents of the zip file to the same directory as your Application.cfc file and thats it! To configure your different environments just edit the com/logicalchaostheory/settings/settings.xml file.

I have also considered releasing another ColdFusion class I have written that will use the settings configuration provided by the settings manager class and automatically setup ColdFusion administrator settings based on what environment the application is running from. For example, for a given ColdFusion application you might have two datasources, one custom tag, and an alias that all need setup. My installer class will take settings specified in the settings manager configuration file and automatically add them to the ColdFusion administrator (provided the application has access to the administrator API). If anyone is interested in obtaining this class please post a comment and I will get back with you about posting up the latest source code.

The source code for the SettingsManager class can be obtained here.

The Problem:

The site had a major memory link throughout the modules. I had ultimately determined that this leak was caused by Flex’s mx.controls.VideoDisplay class since I use it in the majority of the modules of the site. The overall problem is that I couldn’t force the unloading of the modules while using the ModuleLoader class. Now this wouldn’t be that big of a deal because I could just not unload each module and instead let the ModuleLoader class retain each module’s instance in memory for later use when loaded again. Well here is where the next big problem came into play, for reasons I still haven’t pen pointed while sorting through the module system’s source code, the ModuleLoader class creates a new instance out of the loaded module every time you call it to be loaded and it does this with the assumption that the old module would always successfully unload first. This assumption has rendered the ModuleLoader class useless when you are experiencing a memory leak within a module that you cannot get rid of. What the result of this problem was is a high end flash site that perpetually grows in memory every time you visit a section of the website, regardless if you have already loaded it once. After browsing this site and hitting random sections for about 10 minutes this would bump Internet Explorer’s running RAM usage up to about 350 to 400 mbs which was clearly unacceptable for it would have kept climbing if I didn’t stop. Also to mention the many other problems this caused with reference less modules floating around in memory still doing their “own damn thing” as they please because they were attached to some globally controlled events.

The Solution:

As this major problem needed a solution and a solution quick I took full and manual control of the loading and handling of the modules by dropping the ModuleLoader class and using the ModuleManager class instead. This nifty class allows to you directly work with the IModuleInfo interface’s that handle the loading and creation of each module used. What I did with this was store a reference to the IModuleInfo instance for each module I loaded in an object using the module’s url as a key/value pair map. This way I could check the status of each module I was trying to load and create one and one instance only of each when it was loaded which I then stored the actual display objects generated from the IModuleInfo in a map of their own allowing me to call them up at anytime I needed to. My ending result was a website that took no more than 150 mbs in RAM once all the modules have been loaded once. Not to mention the performance increase as well when you aren’t recreating a new instance of a module every time you want to use it.

You may download this package here.