James Ward - RIA Cowboy

Next week I’ll be in Denmark for a few Flex presentations at JAOO and at the local university:

Architecture of a Rich Internet Application (RIA) with Josh Holmes

Developing RIAs using Adobe AIR & Flex

Data Synchronization for Rich Internet Applications

Oct 1st Presentation at the University

Hopefully I will see some of you there!

This week I’ve been at Oracle OpenWorld checking out all of the new applications Oracle has been building with Flex. Some of these seem to be integrating Flex and ADF which is a great combination of technologies! I’ve recorded videos of some of these applications which I hope to edit and publish here soon. One of those videos will feature the new Oracle MetaLink, which is a fantastic Flex application (details on Edwin Biemond’s blog).

It’s great to see Oracle doing amazing things with Flex! And it’s also great to see the community getting excited about the combination of Oracle technologies and Flex. While walking around OpenWorld I noticed a random whiteboard:

Three-tier client/server architectures using Oracle and Flex result in happy users! Wahoo!!!

Having used Linux as my primary desktop for over ten years I can’t help but be a bit jealous of all the great software Windows and Mac users have available to them. But I can’t really blame the software creators for focusing on only those platforms. It’s just purely economics. The cost / benefit of making software work on Linux just isn’t there for most consumer software. What we have always dreamed of is “Write Once, Run Anywhere”. Why can’t software developers write applications for one OS and have it run on all of them?

Adobe Systems has been making great progress turning the dream of consistent, ubiquitous, and cross-platform software run times into reality. This is one of the many reasons I am excited about what Adobe is doing with their software platform technologies and I am happy to be a Technical Evangelist for them. The Flash Player releases have been sim-shipping on all three major platforms (Windows, Mac, and Linux) for almost a year now. But the recent addition to the platform stack, Adobe AIR, is still lagging a bit behind on Linux. Today Adobe posted a beta build of Adobe AIR 1.1 for Linux on the labs.adobe.com site. We all hope that soon even the AIR releases will sim-ship on all three major operating systems. But until then, go download this beta, give it a try and let Adobe know how it works for you.

Flex and JSF have both been widely adopted by the Java Community. In many instances developers must choose between the two technologies. Today Exadel announced a new product called Fiji which alleviates this decision by providing a simple and seamless way to integrate Flex and JSF.

This is very exciting news for Java developers. For more information read the press release, check out the product page, or see the live demos.

Last year at JavaPolis Bruce Eckel, Christoph Rooms, and I did a keynote about Flex. That talk has been posted on Parleys.com (which btw is an awesome Flex app!). You can watch it there, in their Adobe AIR application, or right here using the new Parleys.com Share (beta) widget. If you have any problems watching it here please let me know or file a bug. Thanks!

BTW: You can click on the video to swap the video and slides.

A podcast I recently did with Chariot Solutions has just been published. Let me know what you think.

A friend of mine recently asked me to help him troubleshoot some performance problems with his Flex application. In his scenario he had a large list of data and wanted to filter the data such that each time the search string grew by a character the complex filter would only be run on the results of the previous filter. A very simple approach to this is just to keep a record in each item indicating if the item matched the filter for each search string. Even though the filter function will still run for each item, the complex part of the filter function could easily be isolated and only run for the subset of data which matched the previous filter. This may not be the best way to do this (I’m open to other suggestions) but it was simple. You can see the results of my first attempt here:

Demo 1 (Enter a few numbers in the search field and see how many items are being filtered and how long it takes.)
Source 1

Notice that in order to keep track of how many items are reaching the main part of the filter I increment a Bindable variable inside the filter function:

[Bindable] private var ffCount:Number = 0;
...
private function ff(item:Object):Boolean
{
...
    ffCount++;
...
}

Now since I’ve been programming in Flex for over four years you’d think I’d know better. Every time a Bindable object is modified Flex does a bunch of event dispatching and other plumbing. In this case the Label which is bound to the ffCount variable is also doing a bunch of work each time ffCount changes. As you can see, the results are not great. It takes almost a full second (on my machine) to do the filter on 20,000 items. Obviously this isn’t right.

Lesson learned: A Flex application should never, ever, ever, update Bindable objects in filter functions or other places where the user won’t ever be able to distinguish something changing that rapidly.

A better approach is to update a non-Bindable variable in the loop or filter function, then when the loop or filter is done, copy the non-Bindable variable to a Bindable one. You can see the updated demo using this approach here:

Demo 2
Source 2

This approach is about 10x faster! And only a little bit more work. In this case it’s very easy to be notified when the filter has completed and then update the Bindable variable:

if (event.kind == CollectionEventKind.REFRESH)
{
    ffCount = _ffCount;
}

In retrospect this seems like a silly mistake but I would not be surprised if this sort of thing is causing performance problems in many Flex applications. Data Binding is a very powerful part of Flex but it can also cause performance problems when used incorrectly. I hope this helps some of you to avoid this pitfall. Let me know what you think.

It appears the Flash Player engineering team is making progress on 64-bit Linux support. There are no details yet on when this will ship. But I’m sure they could still use your help.

Intuit has been using Flex in some very exciting ways recently. One of those is to use Flex as a developer SDK for QuickBase. This allows developers to easily build a great user interface on top of the solid and in-the-cloud back-end of QuickBase. You can find out more about this in the QuickBase Developer Program.

A few weeks ago I presented to developers in the QuickBase Developer Program about making Flex applications look and feel great by adding effects and by skinning components. Intuit has allowed me to repost that presentation here. Let me know what you think.