While the exact syntax above would not be possible, closures are in any case the way to go. I explained him how I’d do it and I forgot about the topic until today.

Today while waiting for a long compilation process to complete I’ve came up with an idea on how to improve code readability on cases similar to this. Here’s the cleaneast syntax I’ve came up with (ideas are more than welcome to improve it):

Does it look too verbose? I guess it will highly depend on the exact use case where this is used. But under some circumstances I think the readability can be substantially improved.

createListenerAdapterBasedOn is a package level method. I could have used a utility static method like FunctionUtils.createListenerAdapter. But instead I’ve used a package function because I can reduce the length of the Class + method name (or use the same number of characters to add verbosity and clarity). On the other hand it’s unlikely that this utility class would have more methods.

Documenting functions

This is a concept I’ve never read about or used before, but I think I’ll start using in different places. withParameters method is a completely dummy method that simply returns the parameters it gets but giving them a semantic and contextual meaning. The solely purpose of this method is to improve the readability by converting the method invocation in a Fluent API that can be read as natural language. The method is simply documenting the usage of the call. Putting this together with the Builder pattern and named parameters I discussed a while ago it gives us an incredible weapon to create self-documented code that doesn’t need most-of-the-times useless, needless and confusing ASDoc or inline comments.

If necessary when you have a method accepting several parameters of the same type and that can be confusing to read you could used Documenting functions to create kind of named-parameters:

Here are the details of the implementation in case you are interested in seeing the internal details and some of the tests.

createListenerAdapterBasedOn.as

withParameters.as

createListenerAdapterBasedOnTest.as

This is a feature widely used in FlexUnit but that can be used in lots of other circumstances to reduce the amount of code and reduce its verbosity.

The mechanism to create a package level function is pretty simple. Here are the steps required to create a custom package function:

• You create a class where the function will be defined. i.e: your/package/Assert.as
• You declare a public function at the package level. Note that there’s no class definition.
  package my.pack
  {
      public function assert()
      {
      }
  }
• Then you can use it from every where you wish
package
{
    import my.pack.assert;
   
    public class testPackagefunctions
    {
        public function testPackagefunctions()
        {
            assert();
        }
    }
}

When creating package level functions, the only restriction to bear in mind, is that the function name exposed must be the same name as the name of the file that contains it. i.e. If I expose the assert function, the filename that defines it must be assert.as. This implies that there can only be one function definition per file. If you need more you can create as many files as you need.

Package level functions in AS3 are directly comparable to static imports in Java. In java we can write code like:

By using an static import in Java, static methods defined in the Assert class (in the example above) are made available directly so there’s no need to write Assert.assert. Again this is a feature used a lot in jUnit, Hamcrest or lamdaj libraries.

Autocompletion in Java in regards to static imports is not automatic. If you want to have autocompletion with static imports you can use Preferences > Java > Editor > Favorites and add there the Types or classes you want to use static imports for.

You can find the recording here.

I’ve uploaded all the samples here, you should be able to access the source code in all the samples by right clicking in the sample applications:

• Accordion3D layout.
• Swapping layouts with states.
• Swapping layouts with normal bindings.
• Post transformations sample. Nothing new here, but look at how simple the code is.
• Columns Layout. Another layout to look at, this time it sets the children in columns top to bottom, left to right.
• 2D Text rotation. Simple layout that positions different labels rotating them 45 degrees
• Dancing pile layout. A 3D pile layout that dances. Thanks for the track to the “Music for the peace” Creative Commons initiative. The accuracy of the dancer is not quite good since for simplicity I do only take into account one of every 8 samples.
• 3D Image rotation. The beginning of a Coverflow
• CoverFlow layout
• Carroflow Layout

Finally, here are the slides.

Special thanks to Evtim Georgiev for his support while preparing the presentation and all the materials.
I hope you enjoyed the presentation and that you found it interesting!

You can run the sample application here.
You can find the code here.

I specially like the lightening effects achived with a simple ColorTransform transformation and the really nice cover with transparency effects positioned on top of the pictures (I have to give all the kudos to Alexis Hill from Undefined for his nice touch of design!)

Things I’d highlight from the implementation:

• There’s lot of room for improvement in the positioning function. This was written as a learning sample resource.
• There’s a “random” glitch that misspositions some elements. This normally happens only with the second variation of the layout. I’ll have a look when I have some time
• At the moment item selection doesn’t work by clicking items. Instead use the slider

As always feel free to use it wherever you want at your own risk. The code is provided with no warranties at all.

If you want to learn more on Flex4 layouts you might be interested in reading this.

Watch the recording.

Xavier has done an amazing job preparing this presentation in a very funny and engaging way! I’m pretty sure you´ll enjoy it.

During this session we’ll present you the benefits of reinforcing development and team best-practices from a tooling perspective and how FlexPMD can help you on your daily developments.

We’ll present you not only the basis of how to use FlexPMD but also we’ll present:

• Streamline your development using FlexPMD eclipse plugin
• Create a ruleset that best matches your personal and team needs
• Extend FlexPMD creating custom rules to reinforce your team specific best-practices

Last but not least we plan to release a new version of the Eclipse plugin that will fix most of the issues that the beta version has, improving the performance substantially and easing the configuration process.

If you can’t wait to use this upcoming version you can give it a quick try using this update site (let us know if you find any issue. Also note that the wrapped PMD CLI is 1.1 instead of 1.2, the final version will wrap 1.2).

See you at MAX, Wednesday 9.30am – 10.30am.

During this session we’ll present the basis of the new layout mechanism while trying to go into depth and clarify some more advanced and unknown capabilities. During the session you’ll see the required steps to create custom layouts, how to apply 2D and 3D transformations, the difference between layout transformation and post-layout transformations and layout virtualization.

See you on Wednesday at 15.30

The article summarizes a set of best practices to configure your projects on Flash Builder and Eclipse in general for maximum efficiency and reduced maintenance effort.

As a software engineer joining a new project, I want to be able to get the code quickly, build it, and then run the application. I don’t want to have to work through a complex set up procedure, read countless how-to documents, or learn the detailed ins-and-outs of the application to simply get started.

You can read the article on Devnet.

Do you follow any other best practices? any tips?

The [Mixin] metadata tag is extensively used in the Flex automation API and it basically gives you a very interesting hook. The static init method of any class marked as a [Mixin] will be invoked at a very early point during the application initialization phase by the SystemManager class or FlexModuleFactory. The Mixins are executed before the preInitialize event is triggered on the main Application. The parameter that the init method receives is a reference to the related SystemManager so you can mark the parameter as an ISystemManager, InteractiveObject or whatever better fits your needs. You can read about another interesting use of the [Mixin] on the Global Exception Handler post .

By adding a Mixin class in a library and linking the library to an Application what you effectively get is a hook where the library can initialize itself and release the developer from manually initializing it.

Let’s see some real world examples.

Libraries like fxSpy, deMonsterDebugger, KaptInspect or mrdoob are extremely easy to use but on each project you end up doing some repetitive steps or adding conditionally compiled code to your Main application class.

I’ll focus on a sample with fxSpy where you can launch it from a contextual option when you right click on the application and see mrdoob memory monitor. The only step required to integrate this will is adding the following compiler option:

And this is the library initializer, which basically adds a ContextMenuItem to the contextMenu of the systemManager. Note that we have to wait for the APPLICATION_COMPLETE event, otherwise the Flex SDK will override our contextMenu (it happens on the pre-initialize phase).

In the Initializer you could also intialize the fps and memory monitor provided by mrdoob by simply adding a new instance to the DisplayList.

These are the benefits I see on this approach:

• You won’t have to reapeat yourself in different projects initializing the same libraries always in the same way.
• Your main file won’t be cluttered with infrastructure and glue code to configure your libraries.
• You won’t need to use conditional compilation for this initializations. You can enable or disable all at once by removing the compiler option. Going an step further you could have diferent compiler profiles / environments on your ant tasks or maven builds or even use the -load-config compiler option to externalize your configurations to an xml file.

You can downdload a zip with 2 sample projects, one for the library and the other for the application using it.

Shortly I’ll blog about some of the things I have in my toolbox that could be helpful for you too.

Starting on FP 10.1 and AIR 2.0 you can capture unhandled exceptions or errors globally. Although you can use these new APIs you should always take care of the exceptions where they happen and use this technique only as a diagnosing or logging help or for async exceptions that you can’t really control in any other way.

You might also be interested in these 2 other topics:

• Logging and catching (async) exceptions during invalidation in Flex
• Debugging and getting Stack-trace error dialogs with installed AIR applications

The new API works like:

Christian Cantrell explains some more details on the APIs. You can find further information in the documentation as well.

When working with Flex, and adding the UncaughtErrorEvent.UNCAUGHT_ERROR listener to the loaderInfo object make sure you do it after FlexEvent.APPLICATION_COMPLETE event has been triggered, otherwise you’ll get an “Error #1009: Cannot access a property or method of a null object reference”

To prevent all this required glue code and avoid unnecessary configuration code (that ends up cluttering the main application Class) I’ve created a GlobalExceptionHandler component that abstracts developers a little bit from these sort of problems. The implementation isn’t tighted to the APPLICATION_COMPLETE event, instead it uses the [Mixin] metadata tag. On top of that you can use it declaratively:

You can download the code along with a sample project here. The code for GlobalExceptionHandler:

The code for LogHandlerAction: