• You send a value object (VO) to the server. It comes back with a bunch of additional data. So far so good. But what you get back is another instance than the one you’ve just sent up the wire. Since the original instance may already be referenced somewhere in the application we do not want to simply replace it. We want the original instance filled with the new property values.
• You show the user a form with which he can edit a VO. After he’s changed some values he can either commit his changes (‘OK’ button) or discard them (‘cancel’ button). In this scenario you’ll usually keep a copy of the original VO somewhere handy because you want to be able to restore it when needed. Now the story is the same as the previous one: we want to restore the values of the original instance, not replace it entirely.

So I finally made this convenience method that uses describeType() for introspection as an addition to my ObjectUtil class:

I have needed this so many times I find it hard to fathom why something similar is not included in the mx.utils.ObjectUtil class. It marries perfectly with ObjectUtils.clone().

A simple example:

• overcomplicated nomenclature: in a silly attempt at originality I used military metaphors throughout the library (Sentries, Captains, Spies, etc.). These names make the code actually less transparent to someone who doesn’t know where they originated (i.e. anyone but me). This is in clear violation with my original intent: more readable code.
• too many optional arguments: a lot of different configuration was passed through one method with a bunch of optional arguments. Again, this would not be transparent to someone who read such code for the first time.
• used inheritance (instead of composition) to add the functionality to custom components
• string-based conditionals: "r:propertyA", "f:propertyB" to pass ‘propertyA’ to the result handler and ‘propertyB’ to the failure handler? Not so pretty.

Enter Gigs (a.k.a RIAstar events)

So I decided to rethink the whole thing. To start with, the library name will remain my only attempt at originality. But let’s get down to the real stuff. This is how you use Gigs for tracking native Events:

You can also join a ‘gigs.properties’ file to the application in which you can associate default event types to specific classes. For instance 95% of the time on Buttons we listen for CLICK events. So we register a default for that:

And then we can write the following to do the same thing as before:

Passing property values

The ‘handle’ method takes one additional …rest argument to which you can pass all the event properties you want pass to the result handler. For example (I’ve registered the ListBase class with the IndexChangeEvent.CHANGE event type):

Unfollowing (a.k.a. removing event listeners)

There are three ways to stop following Events.

Very specifically:

Somewhat specifically (this will remove all event handlers that react to a CLICK event):

Loose cannon (removes all event listeners for all event types for the given IEventDispatcher):

To be continued

That’s it for now. I have yet to recreate all functionality that existed in Protection, but I will hopefully get to that soon.

You can even write it in one line – woohoo! -, like this:

CFInvoke assumes that the url of the service and its endpoint are the same. As usual with ColdFusion, this is all very nice and handy as long as your situation matches the default. But from the moment you have to customize a bit, you can start pulling out your hair. And the fact is that the real world has this tendency not to match the default situation.

For example: if the service you want to access has an endpoint that differs from the service url, you’re out of luck. I found the following – completely undocumented – solution to use a custom endpoint:

Notice the underscore? That means you should probably not be using this.

Anyway, while researching this I also figured out the cfscript syntax to do the same thing.

You can also find this snippet on Gist.

This looks like something for me!
If you regularly look at your ActionScript code and find yourself mumbling: “Ah, this class would look nice now, if it were not littered with all these ‘handleThisButtonClick’s and ‘handleThatLoadComplete’s. And then half of them take an ‘Event‘ argument that is never even used in the function. Yuck!“, Protection might be just up your alley.

Don’t mention the war!
If you want your code to be checked as much as possible at compile time and you like to have all your variables nicely typed, please step away from this page. The idea for Protection came to me when I first started mucking around with Ruby, so be warned.

So what’s wrong with my current code?
Let’s have a look at a classic example (warning: I’m going to oversimplify things here for clarity’s sake). Consider the following component:

A simple form

It will have to do three things (all pretty straightforward, you may skip ahead):

• if you click the ‘reset’ button,  the input field shall be emptied
• if you click the ‘submit’ button the content of the form is validated (i.e. there must be something in the input field and it must be formatted as an email address):
  • if the form is valid, your email address will be stored on my server, so I can spam you
  • if it is not, the form will display an error message and invite you to correct it

If you’re not a very good programmer your code might look somewhat like this:

Many people would encapsulate the validation part into its own method. I’ve encountered the resulting pattern many, many times in ActionScript code I’ve seen. There’s obviously still too much going on for one function to handle, so some developers decide to encapsulate the two cases each into their own function. This would result in:

Now you have three distinct functions. Each one of them does only one thing and it is very clear from its name what it is that it does exactly.

Much better!

And yet, I feel sad when I look at this. Because there is one ugly duckling in this class who’s name doesn’t give me the faintest clue of what it does. It only tells me when it will be called, which is frankly useless. And to top things off, it requires a parameter that it doesn’t even really need. Which – besides just being confusing – makes it impossible for me to call that function directly.

The form class outline

This example is but a small component that does very little. Most classes in ActionScript are riddled with these kind of handlers.

Enter Protection
Let me just rewrite 2 lines of the construction code for you, the ones where we added event listeners to the two buttons:

I can now simply remove both handler functions from my code and what remains is a class with a clean outline, less code and much easier to scan too. You may have noticed we don’t even mention the event type anymore. That’s because Protection has some default types mapped to some common classes, which of course you can override. Since on buttons we nearly always want to listen for MouseEvent.CLICK events, I don’t feel the necessity to always explicitly say so. And if you do want to register another type of event, there’s an optional parameter that can let you do just that.

But, but, but, … sometimes I really need that event object in the handler, or at least some property of it…
Never fear, we can fix that in a jiffy. Suppose we wanted to validate the form as the user was typing. We might add the following to the construction:

So what happens here? Instead of passing the entire Event object to the handlers, a certain property is extracted from the Event and passed only to the functions that require it. For instance:

Of course, you can do more complicated things to suit your needs, although Protection‘s main goal will always be to make code clearer rather than obfuscate it. I will elaborate on the possibilities in ensuing posts since this one is already long enough.

Hey, what about AS3Signals?
I know of AS3Signals of course. It’s a nice, mature library with quite some people working on it and many more using it. And it addresses very similar issues, or at least the same grievances with native AS event handling.

But there is one reason why I’ve never really used it: it totally omits the native event system. I do understand the motivation behind this, but the reality is that I have to use components written by others which dispatch only native events and don’t have Signal properties. Not in the least the entire Flex component set.

So this, in short long, is why I created Protection. You can download it or check the source code on GitHub.

Protection on Github

You can check the source code at http://labs.riastar.net/pixel_bender/srcview/index.html and here comes the Pixel Bender kernel source:

I had quite a hard time getting it to work in ActionScript, apparently because I installed the Flex 3.3 SDK just a week ago. Just putting a declaration of a flash.display.Shader class in my code, was sufficient to stop all code from executing, although the VM did not crash. I also got no error message whatsoever.

So after a whole hour of trying everything I could think of, I told the compiler to use the old 3.2 SDK and tadaa: working like a charm. Is it a bug in 3.3 (which was meant to be a bugfix release in the first place) or did I do something wrong?