Watch the recording.

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:

If you want you can disable or enable selectively the Bindings in an mxml document using the BindingManager:

You could enable or disable the bindings according to the visibility of the document.

As an exercise to better understand the details of the new layout mechanism I played a couple of days creating some layouts that I’ll be posting during the next days.

The first layout I created was a Coverflow layout. There already exist several implementations out there for Flash and even Flex. The biggest difference in this implementation is that it’s using standard 2.5D APIs and the standard Flex4 layout mechanism. This translates in a 200 lines of code and quite good performance.

Bear in mind that:

1. This is not production ready code and might have issues.
2. I haven’t optimised the code at all, it’s almost a first pass code.
3. The layout is not using any virtualization capabilities, which means that won’t perform nicely with big dataproviders. I’ll implement this in the future.
4. I’ve added several configuration parameters and some combinations might not work as good as others.

As an extra, and even though Flex4 is not specifically designed for mobile, see how it works in a Nexus One with FP 10.1 beta. In the video below you can see how the application runs just out of the box, no recompilation, no changes at all. Same content that runs in my laptop runs in Enrique’s phone. The performance is really nice! What the Flash Player team has achieved is amazing!
congratulations guys!!

You can run the application here http://www.rialvalue.com/coverflow
You can get the source code here http://rialvalue.com/coverflow/srcview

Which parameter combination do you like more?

The higher number of arguments a method accepts the harder it’ll be to read, understand and test.

When a method needs too much arguments, it is normally a sign of:

1. Poor encapsulation
2. The method is doing more than one thing, breaking the Single Responsibility principle. The arguments define what the method will do, they define and change the method execution path. (i.e. flag methods)
3. Method signatures are harder to read and it’s easier to introduce errors by swapping the order of parameters (specially if they are of the same type). (link to FB issue to highlight parameters. i.e. assertEquals();)
4. Method parameters are all part of the same concept and could be encapsulated in an object with its own type.
5. Arguments belong to different levels of abstraction and are harder to understand.

To reduce the number of arguments in class methods you can consider different techniques depending on what the exact problem is in each case:

1. Create specialised objects that wrap several parameters. i.e. x, y could be a Point instance.
2. Transform method arguments into class properties so that they don’t need to be passed between methods.
3. Create different methods or strategies to fork the behaviour instead of using flag parameters
4. Use factory methods and builders.

All points above can even get worse when overusing optional parameters, which lot of people use to alleviate the lack of method and constructor overloading in ActionScript3 instead of using Builders, Factories of creating different named methods.

If we focus on constructors I think they should only accept:

1. Required parameters for the object to be properly initialised.
2. Optional invariant parameters. Parameters that can’t be changed during the life of the object and that thus need to be specified during born.

Let’s consider the typical Person object with a name, surname, age and a unique invariant Id. We define a constructor with 1 required argument and 3 optional ones:

You could create different instances like:

The code above will compile fine, the compiler won’t complain at all since all declarations are right, but there’re several data integrity errors here, errors that are normally very hard to find and isolate. i.e. p3 is setting the address as the surname. p4 is swapping the surname and the address.

In this case, the Person type and the data might be self explanatory, but there are a bunch of other cases that are not. Having cluttered constructors with lots of optional parameters is quite common when dealing with Custom Events.

What would be interesting is to be able to pass the optional parameters in a named way, removing the order constraint while making the solution more readable, developer friendly and robust to changes:

This solution is a kind of Buider pattern implemented in a fluent way, a train wreck. It’s also somehow mimicking named parameters in other languages. The nice things I really like about this syntax is:

1. It’s a compact expression. It can be written in just one line.
2. The order of the optional parameters is not important anymore.
3. It’s easy to read and prevents parameter swapping. In some cases it can also be read as a natural language phrase.
4. In case of invariant optional parameters the builder can hide the implementation in the build method.
5. It doesn’t break Demeter’s law. Although implemented as a train wreck, each method is applied on the same object.

As mentioned above a common scenario where you could apply this technique is when dealing with custom events. Imagine you want to implement CRUD operations in terms of Persons. You could have:

This implementation would allow you to reuse the same PersonEvent for the different operations without cluttering the constructor with all the different permutations of optional and required parameters in a scalable way. Another option in this case would be using static factory methods (but this won’t solve the optional parameters mess).

Luckily I came across an option in System Preferences to enable the tab key navigation:

• System Preferences
• Keyboard
• Full keyboard access: All Controls

1. View hidden files in Finder

In terminal type:

To hide them again:

2. Manage clipboard from command line

To copy the output of a parameter you can use pbcopy:

The result from pwd will be copied to the clipboard. You can seamlessly use pbpaste

3. Copy directory trees without overrideing

Imagine you’ve got 2 folders: v1 and v2 and you want to copy the contents of v1 inside v2 recursively (merging the contents). With a normal cp command you copy v1 to v2 and there’s a bin folder in both, the bin folder in the destiny will be completely replaced with the one found in v1.

If you were in Linux you would use cp -a, in Mac you can use:

Where:
-p = preserve
-R = recursive
-P = no symbolic links are followed — can be added but this is the default

4. Adding some colors to ls

If you want to see some colors used when executing ls you can add the folowing lines to ~/.bash_profile:

The second line changes the default annoying blue color applied to folders with a more readable red color.

5. VNC client

If you need to connect via vnc to any computer you don’t have to install a vnc client. Open Finder, press command+K and type vnc://host where host is the ip or domain you want to vnc to. A VNC client will automatically pop up.

If you want to allow incoming VNC connections to your MAC you can enable your VNC server open “System Preferences” > “Sharing” and check the “Screen Sharing” option.

6. Remote Login on X server via SSH

There are cases where you have to execute X applications remotely but the server doesn’t have a VNC server neither the possibility.

In these cases you can use:

Note that to be able to execute the commands above you need to have X11. The first line basically allows incoming connections from the server. The ssh command stablishes a connection against the host indicating that any application that nees an X server will be run in the local computer.

Once logged in you can try to execute any visual application. You’ll see that the application pops up locally.

7. Open any document with the default application

You might want to open a random file from the command line in the default desktop application

To open current directory in finder:

8. Open a terminal in current Finder directory

Lots of times you navigate to a certain folder using Finder and then you want to open a Terminal in that folder. To accomplish that you can install openTerminalHere applescript http://www.entropy.ch/software/applescript/

9. You don’t like your dashboard? Disable it!

10. Show current full path in Finder

Do you know any other must-know command or gem?

• FlexPMD 1.0
• FlexCPD 1.0
• FlexMetrics 1.0

And our first beta for the new FlexPMD Eclipse plugin that will better integrate FlexPMD into your development workflow!!

You can find all the documentation for FlexPMD on the wiki and for the plugin http://opensource.adobe.com/wiki/display/flexpmd/FlexPMD+Eclipse+plugin

If you have any question, problem or suggestion you can use the public forums.

• Unused code (functions, variables, constants, etc.)
• Inefficient code (misuse of dynamic filters, heavy constructors, etc.)
• Over-complex code (nested loops, too many conditionals, etc.)
• Over-long code (classes, methods, etc.)
• Incorrect use of the Flex component lifecycle (commitProperties, etc.)
• A report is produced describing the violations of a given rule set. FlexPMD includes a rule set that is broad ranging and continually growing. It is also straightforward to create new rules and users are encouraged to do so.

FlexPMD can currently be invoked from:

• The command line
• Maven
• Ant
• Automator on Mac OS X
• Currently, FlexPMD produces a XML report by default, plus an HTML report when invoked by the Maven site plugin. The XML report can then be consumed by any PMD reports pretty printers (like the PMD hudson plugin).

An Eclipse plugin is under consideration.

Some good information on how to start using it can be found in this blog post.