Kenny Bunch

For anyone unfamiliar with asfunction I will explain the basics first. For those already comfortable with it, but want to understand how to resolve it’s call path and scope to a class instance, feel free to skip to the latter part of this article.
(more…)

In creating Flash content for the web you are given the ability to push new versions of your application by merely overwriting your .swfs on your server. However, your .swfs are served by the rules of the browser that they are hosted in on the client’s system. It is important to understand that this end client application requests new content based on rules of it’s application settings.

A browser may request new .swfs everytime it hits your site (not caching anything) or it may follow some other rule of content purging(based on total content cached etc.). Therefore, it is important that when you overwrite an application .swf that you force it to update on a client system. If you understand how an browser treats document requests this is quite an easy task. A normal document request may look like http://www.foo.com/foo.swf, where foo.swf is the document requested. If you append what is called a query string to the end of that request, you can request the same document but send data to it like http://www.foo.com/foo.swf?APPVERSION=1.23. Interestingly enough, each unique query string added treats the request as a new one, forcing the document to be loaded again. With this knowledge, you can see that if I add APPVERSION=1.24 that I will get a new .swf, and 1.25 a new .swf, etc. However, due to caching once I download the .swf and the url doesn’t change on the next request the .swf is cached until it is purged by a changed request or settings purge. This behavior allows you to force updates to your users when they make requests by merely adding a versioning variable to the source tags in the embed and object code for your .swf, and in addition to efficiently cache .swfs as well. Caching is important, for instance if the client has a slow connection, say 56k and the file is 150kb. If the .swf hasn’t changed they will have to wait to download it each time they visit your site. On the other hand if it is cached on a version basis then they can use a cached version of the base .swf and only load ondemand needed items (data requests, etc.). If you use a content versioning system like CVS, you can easily use the current document version as the version for your swf update. This allows you to be in sync with your system and automate this versioning methodology if you have a formal build script/process.

Another important thing to point out is the FlashVars attribute. This html attribue also allows you to pass information into your .swf. This is an important attribute and should be used to pass all data in. By using the FlashVars attribute all data passed in is sent in to the currently cached .swf, it doesn’t force an update of the .swf. If however, you use a query string to pass all your data in, it will force the .swf to be purged anytime you change a variable. This could be bad, if for instance, you had a 100kb swf that had a var which changed constantly. The constantly changing var would cause the 100kb .swf to be served on every request instead of being efficiently cached. If your site was heavily hit, your servers would have to work harder.

[UPDATE] I forgot to mention how to send data into a Flash 5 swf. For those looking for a high adoption rate with Flash 5, you can not use Flash Vars, because it is a Flash 6 feature. In these cases you have to append your data to the query string of your embed. This does not mean that you are at a loss and will have no way of getting around loading the swf everytime. There is a trick you can play. This trick involves putting a proxy swf in the embed that in turn loads your application. The proxy is a blank swf with the simple purpose of loading your swf and maintaining passed in parameters. You app swf is versioned by the proxy appending the version query to its loadMovie operation. The app swf once loaded can then access all the html parameters by referencing them in the proxy. This allows you to have a swf (the proxy) that is less than 1 kb that takes the non cache hit, making it minimal. The application swf is still cached and can access the passed in values.

Hopefully, my explanation is clear and helps out. Post if you have any questions.

I use mx.utils.Delegate.create constantly, however in looking at the source code, there are some memory inefficiencies. In the create method, there is a function literal (the var f). By creating this function literal, the create method is actually prolonging the scope of it’s arguments and it’s local variables in the scope of f for the lifetime of f. So what does all this mean? Well, it means that in the scope of f you have create’s argument’s obj and func still available. Yet, f reference’s these values by creating local variables from static properties attached to the function itself, instead of accessing them directly.

(more…)

In looking at pieces of the MM framework, and how a lot of developers write their own code, I’ve noticed a lot of magic string usage. What do I mean by a magic string, let’s examine the following piece of code for a definition:

myComponent.addEventListener(“change”, this);

In this example, “change” is the magic string. The reason that it is a magic string is that code is dependent on that string being correct, but yet there is no formal assertion that it is correct. For example, if in the example I mispelled “change” as “chnge”, my code would fail silently. Though this may not be catastrophic, you are left to your own debugging methods to figure out what went wrong. Fortunately, there are several ways to remedy this. The easiest and most common is to implement some sort of constant variable in your code to represent the string. For example:

// definition : mx.controls.ListBox.EVT_change = “change”;
myComponent.addEventListener(mx.controls.ListBox.EVT_change, this);

In this example, the dispatching object actually has a static property EVT_change that is equal to the string and which is used to represent the string. If you use this method and type in a property that doesn’t exist, you will get an error. So with little effort you can have strict typing, better debugging, and more relaxation time.