I tried a lot of different approaches and will show three of them.

I also discuss how to use mockito to supply us with mocks in a way that doesn’t interfere with the BDD approach.

You can read it here

More

more

Silverlight 4 not only brings in all these features, but also a pile of others.  Interestingly, they seem to be making a direct pitch against Adobe AIR with many of the features.  The new Elevated Trust Applications feature (for out-of-browser apps), enables a host of features typically reserved for desktop applications: Local file access; Notifications API; Full-screen full-keyboard access; Cross-domain policy-free networking; and Drop targets.  Of course, features aside, the huge advantage of the Silverlight desktop approach over AIR is that there is only one runtime plugin required.

At the speed Microsoft is moving forward with Silverlight, Adobe is going to have to start seriously upping their commitment to the Flash platform if they want to stay at the top of the game.  Up to now, they could always give the argument of Flex being more feature-rich, and the ease of adaptation to the desktop with AIR – with both of these arguments now void, and Microsoft firmly remaining miles ahead in the developer tooling scene, Adobe’s work is cut out.  They still have greater marketplace penetration with Flash player, but that lead is only going to narrow also.

You’ve got to love competition!

A month back a live webcast took place titled ‘Transcending the client experience’ that focused primarily on the use of RIA in financial services and particularly within Morgan Stanley’s Matrix. A recording of the webcast is now available. I offer a small summary of some of the highlights here.

RIA offers a zero footprint in terms of installation effort and supports real time data presentation through simple yet rich user interfaces. It is bringing the business closer to its clients and is more than just technology in that it is solving real world business problems.

The progressive trends are as follows. There is a front-end shift in that applications are now more driven by user experience and design than previously, can represent large amounts of varied and real time data more coherently and concisely and are increasingly beginning to approximate thick clients in that they are stateful and taking on more of the responsibilities of the server side.

Going forward opportunity is seen in adding threading support and mobile device support to Flex and also in migrating the vast amount of legacy applications currently existing to RIA technology. Morgan Stanley’s Matrix received special recognition throughout being one of the largest production Flex applications in the world, if not the largest, at more than six hundred thousand lines of code developed in the timeframe of a year.

[ Recording of the "Transcending the Client Experience webcast", organised by Adobe and Finextra. Participants in this hour and a quarter long session discuss how developers at financial firms use rich Internet application technologies to integrate real-time data, with the delivery of audio, video, reports and rich interactive charts to trading applications.]

[Panel participants: Hishaam Mufti-Bey (Matrix founder and global director at Morgan Stanley), Stephane Malrait (Global Head of eCommerce at Societe Generale), Mark Greenaway (Adobe), Trevor LaFleche (Senior Analyst at Financial Insights). Moderator: Vivake Gupta, Managing Director, Lab49.]

I recently helped a colleague out with an article on Flex vs. Silverlight in the Enterprise.  Both of us have a strong .NET background, and have more recently been heavily involved on a massive enterprise-scale Flex application.  Although I still stand by the original article, I realise it’s impossible to accurately and fairly detail each platforms’ strengths and weaknesses in one post.

So, I plan to start a bit of a series – comparing different user experiences as created with Silverlight and Flex, and hopefully reaching a conclusion on the benefits of each platform, based upon developer experience/efficiency, and of course how the end result meets the original client requirements.

Each post will focus on a technical area that you may find within any enterprise RIA.  Example areas could be video streaming, datagrid customisation, push messaging, theming/skinning, just to name a few.

It’s as much for my own benefit as anyone else’s – in order to deliver the best client experience, you HAVE to know what the best tools or platform are for any given situation!

“Although this range of numbers is enormous, the cost of this range is precision. The Number data type uses 52 bits to store the significand, with the result that numbers that require more than 52 bits to represent precisely, such as the fraction 1/3, are only approximations. If your application requires absolute precision with decimal numbers, you need to use software that implements decimal floating-point arithmetic as opposed to binary floating-point arithmetic.”

Seems to me they’re basically saying that if you have an app where number precision is important, then don’t use Flex. While Flex can create some great looking applications, my impressions are that for financial and LOB applications – Silverlight with the pedigree of C# and the wide range of 3rd party controls and tools should be the first choice.

Update: I’ve just found a 3^rd party library with a simplified implementation of the decimal data type. http://www.fxcomps.com/components.html Naturally Flex is extensible, so it’s possible to solve most problems one way or another.  However it’s nicer to have an out of the box solution where things like this are present without you having to even think about it.

• Decompiles and analyzes the application to identify security issues.
• Identifies insecure code, and deployment setup.
• No need for access to the code
• And it is Free

Definitely worth trying, finally someone creates a tool to address Flash security.

I have seen examples where there has been spent a lot of time developing code to accommodate for this, with the only result that code base has a lot of non production code which can cause bugs and add an overhead to maintenance of the system. In my eyes that would be wrong, test/mock coding is money wasted on valuable time that should be spent on developing features.

So why not use something which already (almost) exist. When you use HTTPServices, you can point to nearly anything that gives you some kind of XML result. Pointing to a static XML file on the server should give you almost the same as pointing to a service which would serve you dynamic XML.

package com.lab49.spike
{
	import mx.core.Application;

	import mx.rpc.AsyncToken;
	import mx.rpc.http.mxml.HTTPService;

	public class StubHttpService extends HTTPService
	{
		public var stubUrl : String = "";

		private function get stub() : Boolean
		{
			var stubParam : String = String( Application.application.parameters[ "stub" ] );

			return stubParam == "true";
		}

		public override function send( param : Object  = null ) : AsyncToken
		{
			if( stub )
			{
				url = stubUrl
			}

			return super.send( param );
		}
	}
}

And when you use it, insert “stub=true” in your url, and add this to your StubHTTPService:

<spike:StubHttpService
	url="http://localhost:8080/spike/myService"
	stubUrl="xml/stub.xml"
	...
/>

The presentation is available on AdobeTV.

Who said Adobe Flex couldn’t be used for critical systems? If Adobe wants Flex to be seen as a serious framework in the enterprise, this is the kind of projects they need to show more of.

Over a series of posts I will cover some of the experiences gathered from this and other projects I have taken part in. There is usually more to a project then just choosing a framework like Cairngorm, PureMVC or one of the many IoC containers which are popping up everywhere.

• ActionScript 2
• ActionScript 3
• C#
• ColdFusion
• haXe
• Java
• Perl
• PHP
• Python
• Ruby

If you have an interest in presentation patterns, I would recommend to look at Paul Williams great presentation pattern blog series. He also has a series covering how to unit test the different patterns, which most developers should find interesting.

Tomorrow I will present “Flex Client Architecture & Best Practices”, where topics like PresentationModel and unit testing will be covered.

As I also announced on 360|Flex Europe in Milan, Adobe Consulting will over the next few months share some of our best practices in a series of articles. A topic could be for example “Cairngorm and Modules”. Steven Webster has posted a call for topics blog post

Presentation Cairngorm Deepdive

In my presentation – Cairngorm deepdive, I’ll be covering some of the history behind the Cairngorm Microarhitecture, how to use it on large scale projects, how to handle security, and also shed some light on the future of the framework.

There is also a second presentation covering Cairngorm, Neil Webb will present Cairngorm for beginners.

If you haven’t already signed up for the conference, you can do so here

Given the asynchronous nature of making service calls in Flex (or Ajax apps or any other RIA technology) you can run into race conditions if you simply fire off all of the service calls at once, especially if the result handler of one service has a dependency on a piece of data that was loaded from a different service. Additionally, you need to be notified of when all the initialization services have finished so you can perform any rendering actions to make the app available for business.
(A concrete example of this would be an app that needs to load a list of position dates from a service, and will then pick the latest position date as a parameter into a number of other service calls that populate DataGrids on the screen. You must defer the calls to load each grid until the positionDates service has returned).

The first approach that my team had to implementing this would be to fire off the first service in the creationComplete handler of the application, then at the end of that service’s result handler fire off the second service, and so on. Given an application with two HTTPServices (svc1 and svc2) declared and a creationComplete event handler to kick the processing off, a contrived example of this would look like this:

private function onCreateComplete(event:Event):void
{

    // wire service result handlers
    svc1.addEventListener(ResultEvent.RESULT, result1);
    svc2.addEventListener(ResultEvent.RESULT, result2);

    // invoke first service
    svc1.send();

}

private function result1(event:ResultEvent):void
{
    // do something with the result of svc1, then invoke
    // svc2
    svc2.send();
}

private function result2(event:ResultEvent):void
{
    // do something with the results of service 2, then
    // perform actions to make app available
}

This type of design quickly grew brittle and unmanageable. Readability is forfeited as you need to navigate around all of your event handling methods to discern the ordering of events. Adding new service calls or changing the order becomes an exercise in figuring out where to insert the next call and how to hook it up into the flow. If you have certain subclasses of your application class that needed additional service calls (as my project does), it is difficult to insert a new service into the flow.

As a piece of refactoring, I created a neat little class to give us an easy way to put the ordering of the services in one central location, decoupling the service flow from the result handlers. It maintains an internal list of services to call, in the order that they are added to the chain. When you add an HTTPService (and it’s corresponding event handler) to the chain, a generic event handler is added to listen for the result event. When this handler is invoked, it’ll call the actual event handler that you provided for that service, and will then pop the next service off the chain and call it. You can also specify a final handler method to be called once all the services in the chain are finished:

public class ServiceChain
{
    private var _chain:Array = new Array();
    private var _curEntry:Object;
    private var _chainFinishedHandler:Function;
    public function ServiceChain()
    {
        super();
    }

    /**
     * @param f
     * Setter for the chainFinishedHandler, a method that will be
     * invoked when the final service has returned.
     */
    public function set chainFinishedHandler(f:Function):void {
	_chainFinishedHandler = f;
    }

    /**
     * @param svc
     * @param resultHandler
     *
     * Adds a chain entry for the HTTPService and resultHandler pair
     * (added as an anonymous object with svcclass and handler
     * properties).  An event listener is added to the svc class to
     * invoke the genericOnServiceResult when the service returns.
     */
    public function add(svc:HTTPService, resultHandler:Function):void
    {
        // redirect the results of all service calls to the generic handler
        svc.addEventListener(ResultEvent.RESULT, genericOnServiceResult);
        _chain.push({svcclass: svc, handler: resultHandler});
    }

    /**
     * Pick the next service off the chain and invoke it's send method.
     * If there is no service on the queue, we are finished.  Invoke the
     * chainFinishedHandler if present.
     */
    public function run():void
    {
        _curEntry = _chain.shift();
        if (_curEntry == null) {
            if (_chainFinishedHandler != null)
                _chainFinishedHandler();
            return;
        }
        _curEntry.svcclass.send();
    }

    /**
     * @param event
     *
     * The service has returned, so invoke the actual event handler for the
     * service, then call run() to pick the next service from the chain.
     */
    private function genericOnServiceResult(event:ResultEvent):void
    {
        _curEntry.handler(event);
        run();
    }
}

Then the application code simplifies to:

private function onCreateComplete(event:Event):void
{
	var chain:ServiceChain = new ServiceChain();
	chain.add(svc1, result1);
	chain.add(svc2, result2);
	chain.chainFinishedHandler = chainFinished;
	chain.run();
}

private function result1(event:ResultEvent):void
{
	// ... do something with the result of svc1
}

private function result2(event:ResultEvent):void
{
	// ... do something with the result of service 2
}

private function chainFinished():void
{
	// make app available
}

We’ve now decoupled the ordering of service calls from the handling of each service result, have a way for subclasses to insert their own calls to the chain (making the chain a protected member), and have an easy way to execute logic when service calls have finished. This pattern I suppose is something akin to a Chain of Responsibility with a different flavor to handle the asynchronicity of each operation. I’d imagine this type of thing could be useful in Flex, Silverlight, or any other rich client app which must initialize itself from remote services called asynchronously.

Both Rails and Flex are considered “best in class” when it comes to rapid development, and during todays 3.5 hour session we will show how Flex can integrate with Rails using a REST based back-end.

The presentation can be found here, and the code is on google code

Today I presented Eliminate Waste in Java Development with Adobe Flex together with Espen Dalløkken from Ezmo at JavaZone in Oslo, Norway. A short outline of the presentation on how to eliminate waste in Rich Internet Applications:

• Remove your Java MVC; Spring MCV, WebFlow, Struts 2…
• No MVC, less configuration and no flow configuration on server, your application is data driven, why should the server care about the flow on the client!
• LCDS, LiveCycle Data Services on top of your existing application, Integrating with Spring, Hibernate, EJB, using one of the LCDS adapters, or using a custom adapter.
• Streamline handover between design and development teams using Flex/Flash Component kit.