[![](/wp-content/uploads/2010/04/ScreenHunter_01-Apr.-08-20.11.gif "ScreenHunter_01 Apr. 08 20.11")](/wp-content/uploads/2010/04/ScreenHunter_01-Apr.-08-20.11.gif)

Twitter can be a funny beast, what makes it great can also make it poor. I use [Twhirl ](https://www.twhirl.org/)which keeps me updated any time one of the people I follow tweets about something, the only problem is that so many people tweet that if I dont happen to see it within about and hour or so of the Tweet, ill miss it. This time however I was lucky enough to catch a tweet by [@Joa](https://twitter.com/joa) about his new Inversion of Control and functional-programming-like library, [Funk AS3](https://code.google.com/p/funk-as3/).



As I have been getting well into [RobotLegs](https://www.robotlegs.org/) (a Dependency Injection MVCS framework) recently I was extremely interested to hear about this new project by Joa who I respect very much as a brilliant coder not least because of his excellent work on low-level Flash byte-code optimisation (see [Apparat](https://code.google.com/p/apparat/)).

Joa has taken a different approach to doing dependency injection. The approach most frequently used (and the one used in SwiftSuspenders / RobotLegs) is to use meta-data to declare to a number of variables for injection. You then map a class to be injected and instantiate it using the injector.

As an example, with Swift Suspenders you would define a class for injection with something like the following:

```

class MyInjectedClass
{
public function sayHello(toSay:String)
{
trace("Hello "+toStay);
}
}

var injector : Injector = new Injector();
injector.mapSingleton(MyInjectedClass);

```

Here we are telling the Injector to make a single instance of our class and hold it internally ready for when it is next requested, such as:

```

class MyDependantClass
{
	[Inject] public var myClass : MyInjectedClass;

	public function performAction()
	{
		myClass.sayHello("World");
	}
}

```

Here the [Inject] meta-data indicates that we want the framework to supply the class with an instance of type MyInjectedClass. The final part is to make an instance of the dendant class and inject into it:

```

var dependant : MyDependantClass = new MyDependantClass();
injector.injectInto(dependant);
dependant.performAction();

```

As you can see this is a nice way of handling inter-module dependencies in your code, when coupled with a MVC framework such as RobotLegs it becomes and extremely powerful yet elegant way of coding.

It however isnt perfect and Joa, on his [google code page](https://code.google.com/p/funk-as3/wiki/IoC) mentions three drawbacks of this method:

<blockquote>*   Your injected properties are publicly exposed and mutable.
*   describeType is very expensive.
*   Steep learning curve.
This is where he suggests his alternative method, which is quite ingenious. Using the same example as above you would see something like the following:

```

class MyInjectedClass
{
	public function sayHello(toSay:String)
	{
		trace("Hello "+toStay);
	}
}

bind(MyInjectedClass).asSingleton();

```

Then the dependant class would look like the following:

```

class MyInjectedClass
{
protected var myClass : MyInjectedClass = inject(MyInjectedClass);

    public function performAction()
    {
    	myClass.sayHello("World");
    }

}

```

And making an instance of it could be as simple as:

```

var dependant : MyDependantClass = new MyDependantClass();
dependant.performAction();

```

As can be seen there are some benefits to this method, the biggest one in my opinion is that injected properties dont have to be public as they are provided by the call from within the class scope rather than from outside.

So how does Joa perform this magic? By abusing a little used ability of the Actionscript programming language known as package-level-functions. These are throwbacks from the old AS1 &amp; AS2 days of global functions. There are actually a couple of common examples in AS3 still such as getTimer() and getQualifiedClassName() still used. What Joa has done is to use these package level functions as a method of generating concise looking code reminiscent of functional programming.

Performance wise, im not entirely sure whether by using package-level functions instead of describeType() calls used in meta-data driven IoC frameworks is any faster as Till Schneidereit of Swift Suspenders suggests:

> I don't think that Funk's approach is any faster than an optimized
>
> metadata-based IoC container: describeType may be slow (as in "takes a
>
> few dozen microseconds to run"), but is only ever called once for each
>
> class an instance of which is injected into. After that, it's just a
>
> straight iteration over an array for all injection points instead of
>
> Funk's multiple method calls for each injection point.
> So the next step for me is to run some tests to see how things pan out. Either way im very impressed with both approaches and cant wait to see what kind of exciting advances will be developed in the coming months.

Just as a follow up from my post [on the bleeding edge](https://www.mikecann.blog/programming/on-the-bleeding-edge/) I thought I would post a rather interesting image @srivello made and @jhooks shared. Its a relationship between the main components in the MVCS meta-framework in [RobotLegs](https://www.robotlegs.org). Its pretty good for anyone that (like me) preferrs to see a diagram when trying to grasp the concept of a new framework:



(click to enlarge)

[![](/wp-content/uploads/2010/03/ScreenHunter_01-Mar.-23-15.51.jpg "ScreenHunter_01 Mar. 23 15.51")](/wp-content/uploads/2010/03/ScreenHunter_01-Mar.-23-15.51.jpg)

Well it thought it was about time I did some posting about my personal project im working on at the moment as I havent spoken about my coding for a while.



For a while now (alot longer than I had hoped for) I have been working on a project that falls outside the realms of my usual kind of games-related projects. Im not ready do describe exactly what it is yet but im excited about it.

For months I have been struggling with the techinal challenges the project has entailed and I have dabbled with many new and highly diverse technologies including [JavaFX](https://www.mikecann.blog/programming/flirting-with-javafx/) (Java), Qt (C++) and Mono (C#).  I have been looking for a cross-platform technology that will get the job done that I need and doing it in an elegant manner.

I thought I had found it with a combination of JavaFX and straight Java using the PureMVC framework. I however was plagued with problems throughout with Bonjour, jGroups, JmDNS, JNI and JNA.

So after months of work, hardship and struggles I read a very interesting article on the up-and-coming Adobe AIR 2.0  that was opened for beta in December. With 2.0 Adobe are bringing NativeProcess  to Air. What this means is that you can you can execute native code (.dlls, .so, .jar etc) from Air. To me this was bloody brilliant as I had been[ playing with Air reccently](https://www.mikecann.blog/programming/audiobook-organiser-v1-3-0-dragndrop/) and my [day-job](https://www.mikecann.blog/photos-personal/playdemic-my-fist-day/) heavily involves Flex and I simply love the power and beauty of Flex.

So what this meant to me was that I could write the bulk of my project including its interface in my much preferred Adobe Flex (Air) and then use Native Process to communicate with a small kernel of Java that would do all the dirty work that Air itself cant do.

So after a little playing with [Flerry](https://www.riaspace.net/2010/01/flerry-flex-java-bridge-for-adobe-air-2-0/) for Air->Java bridge I started to think about the structure of the code and the framework I would use. For my initial few runs at this project I had been using the Java version of PureMVC. I really like some aspects of PureMVC but I think its can be so overly cumbersome in some circumstances (ill write another post on this in the future I think). So instead I looked at the alternatives.

I have been using [Mate](https://mate.asfusion.com/) alot recently at work and on my own mini-project the [Audio Book Organiser](https://www.mikecann.blog/programming/audio-book-organiser-air-mate-flex-4/). However as this project is partly for my own learning and personal growth I decided to look at what else there was out there. From the videos by [Jessie Warden](https://www.mikecann.blog/fun-videos/jessie-warden-flash-flex-videos/) I had heard about [Robot Legs](https://www.robotlegs.org). Apparently this framework has been around for a while, but it was the first I had heard of it. Taking at look at it I immediately became very excited as it looks like it offers all the things that make PureMVC great but without the extra coding-baggage that goes with it.

To add to my interest it appears another very interesting, very new action-script technology has been introduced into Robot Legs called [Signals ](https://github.com/robertpenner/as3-signals)by Robert Penner. Signals is an alternative to the standard events dispatching method found throughout flash (more on this in another post).

So why have I called this post "the bleeding edge?". Well Adobe Air 2.0 is still in beta and has only been for a month or so. Its so new that some parts still havent been documented atall and the only way to find out how they work is to post a msg to the devs on the forums. Signals is also new and its integration into Robot Legs is very new indeed (last coupple of weeks). So at the moment I feel as if im at the forefront of some very new, very exciting technology, a stark contrast to my fiddlings with the ancient Java.

I realise this post is very text and tech-heavy but I needed to post about it before I forgot all the pain I have gone through with this project to get where I am at the moment. Future posts ill be delving a little deeper into some of my experiments with these new technologies ;)

robot legs

robot legs

robot legs