Drew Bourne

Constructors & apply

2009-02-17T00:00:00-08:00

asx has gained a new feature: newInstance(klass:Class, parameters:Array).

It does exactly what it looks like – creates a new instance of a class passing in the given parameters to the constructor.

var event:Event = newInstance(Event, ["click", true, false]);

Perhaps not so useful for Event, however when dependency injection starts calling it becomes an issue to support injecting values in constructors.

ActionScript 3 has changed enough from AS2 that its no longer possible to treat constructors as functions and call apply() on them with our required parameters. (This example might be a little bit off as I haven’t written AS2 for years, apply might have to be called on the prototype).

var event = Event.apply(null, ["click", true, false]);

Instead of a nice terse one-liner to invoke a constructor with an array of parameters AS3 requires us to do this hideous business:

public function newInstance(klass:Class, args:Array=null):Object {
  args = args || [];
  switch (args.length) {
    case 0: { return new klass(); }
    case 1: { return new klass(args[0]); }
    case 2: { return new klass(args[0], args[1]); }
    case 3: { return new klass(args[0], args[1], args[2]); }
    // ... ad infinitum for as many arguments as you want to support
  }
}

And I would like to share why.

AS3 gets compiled by mxmlc into bytecode. Bytecode is a way to represent the operations of code in a small and efficient to execute manner. The bytecode operation that constructs a new instance is called construct.

This bytecode expects the next value in the bytecode to be the number of parameters to pass to the constructor. These parameters must already exist on the stack (see http://en.wikipedia.org/wiki/Stack_(data_structure)). Items on the stack are references to Arrays, Booleans, Numbers, Class instances etc.

It is not possible for the bytecode for construct to say:

“use the (number of) items in the array at the top of the stack as my parameters”.

And so unless a new bytecode operation is added to the AVM2 we must continue to use code similar to the epic switch statement given above.

newInstance() is available in asx and is taken from my work on implementing dependency injection containers, and an AS3 bytecode generator. Similar solutions exist in Prana/Spring ActionScript and other DI frameworks.

Flash Player VM / AVM2 Specifications PDF

Conditional Complexity

2009-02-17T00:00:00-08:00

In starting a new project recently it occurred to me today to enable some of Checkstyle configuration options that had previously been too noisy on legacy projects. This will hopefully help me and the other developers keep the Java code of this project clean, and free of common bad practices.

One of the checks enabled was cyclomatic complexity.

The complexity is measured by the number of if, while, do, for, ?:, catch, switch, case statements, and operators && and || (plus one) in the body of a constructor, method, static initializer, or instance initializer. It is a measure of the minimum number of possible paths through the source and therefore the number of required tests. Generally 1-4 is considered good, 5-7 ok, 8-10 consider re-factoring, and 11+ re-factor now!

Taken from Checkstyle metrics

I was feeling game so I set the limit to 5.

And very quickly I coded something that looked bad, felt hacky, repetitious, and lo — it was. Checkstyle had flagged it with a cyclomatic complexity issue. Here is what the code looked like (although I have transcoded the Java to AS3 as the solution is applicable to both, and removed some information not necessary for the examples).

public function validateObject(object:Object):void {
  if (conditionA || conditionB) {
    throw new ObjectValidationError(object);
  }
  if (conditionC || conditionD) {
    throw new ObjectValidationError(object);
  }
  if (conditionE || conditionF) {
    throw new ObjectValidationError(object);
  }
  // and many more if-statements
}

In my haste to spike out this piece of functionality I had violated “Don’t Repeat Yourself”. Even before I noticed the Checkstyle warning I had started refactoring this code. Attempt two was getting a little better.

public function validateObject(object:Object):void {
  if (conditionA || conditionB) {
    invalid(object);
  }
  if (conditionC || conditionD) {
    invalid(object);
  }
  if (conditionE || conditionF) {
    invalid(object);
  }
}

protected function invalid(object:Object):void {
  throw new ObjectValidationError(object);
}

The repeated if with the multiple conditions were still triggering the cyclomatic complexity warning and there was still too much repetition.

public function validateObject(object:Object):void {
  validate(conditionA && conditionB, object)
  validate(conditionC && conditionD, object)
  validate(conditionE && conditionF, object)
}

protected function validate(isValid:Boolean, object:Object):void {
  if (!isValid) {
    throw new ObjectValidationError(object);
  }
}

The improvements in readability, maintainability and DRY-ness should be evident in the version above.

The validity conditional in validate() is about as clear as possible,
Error instantiation and throwing appears only once,
validateObject is almost declarative — which is a good thing for validation, and a hint to future improvements.

It has taken much longer to write up this post then it took to see the problem, test, and iterate on the solution. I was surprised at how quickly turning on the additional Checkstyle checks were, and encourage you to go find a tool that will help improve your /knowledge|code|workflow|productivity/.

Feathers and Weights

2009-02-15T00:00:00-08:00

Taking the feathers and weights from plucking chickens its time to add them up. Lets take a look at how to convert a for-loop to a reusable functional solution.

var feathersPerChicken:Array = pluck(chickens, "feathers"); // Array of Numbers
var weightsPerChicken:Array = pluck(chickens, "weight"); // Array of Numbers

The basic for-loop to add up the number of feathers looks like this:

var totalFeathers:Number = 0;
for (var i:int = 0, n:int = feathersPerChicken.length; i < n; i++) {
  totalFeathers += feathersPerChicken[i];
}

As this loop iterates over every item in the Array we can simply replace it with a Array.forEach

var totalFeathers:Number = 0;
feathersPerChicken.forEach(function(numberOfFeathers:Number, i:int, a:Array) {
  totalFeathers += numberOfFeathers;
});

Instead of manually managing the iterator index i and length n, Array.forEach does that work. However in its place we have to declare an anonymous function to close over the scope of totalFeathers and add to that variable the numberOfFeathers. There is still a lot of boilerplate code in that block that could be removed or hidden as it is not helping us understand what the code is doing.

For the next steps lets replace the for loop and Array.forEach with a function call for what the intention of the code is: adding up a bunch of numbers, or rather getting the sum.

var totalFeathers:Number = sum(feathersPerChicken);

Now that is much clearer.

Implementing sum could be as simple as wrapping up the previous example into a sum function. It could then be used to add up the weights of the chickens too.

function sum(numbers:Array):Number {
  var total:Number = 0;
  numbers.forEach(function(number:Number, i:int, a:Array):void {
    total += number;
  });
}

var totalFeathers:Number = sum(feathersPerChicken);
var totalWeight:Number = sum(weightPerChicken);

By replacing the for loops from the original example the code is now much easier to read, and tells exactly what its doing. A couple of more subtle gains from this are the scope is kept clean of temporary variables, and there is now a hook to change how the total is calculated without affecting the signature of the sum function.

sum() is available in asx and implemented using a number of other helpful functions: inject and add.

Plucking Chickens

2009-02-13T00:00:00-08:00

I have some chickens, and I want to know how many feathers they have each.

var chickens:Array = [new Chicken({ feathers: Math.round(Math.random() * 5000) }), 
                      new Chicken({ feathers: Math.round(Math.random() * 5000) }),
                      new Chicken({ feathers: Math.round(Math.random() * 5000) })];
var feathersPerChicken:Array = null;

I would rather not sit there and iterate through my chickens, picking up each one, counting its feathers and then letting it run off, remembering where I got up to, and then possible forgetting which chicken I was up to.

for (var i:int = 0, n:int = chickens.length; i < n; i++) {
  var chicken:Chicken = chickens[i];
  var feathers:Number = chicken.feathers;
  feathersPerChicken.push(feathers);
}

Eww, I almost stepped on a temporary variable one of the chickens left behind.

Good thing we know how to clean that up with Array.map.

var feathersPerChicken:Array = chicken.map(function(chicken:Chicken, i:int, a:Array):void {
  return chicken.feathers;
});

I just remembered I need to know the weights of all the chickens too. We should probably get out our map again.

var weightsPerChicken:Array = chicken.map(function(chicken:Chicken, i:int, a:Array):void {
  return chicken.weight;
});

It is looking pretty similar to last time. Could we do something to remove the repetition and show only what changes? Lets give this a few go’s.

function getChickenProperty(property:String):Function {
  return function(chicken:Chicken, i:int, a:Array):Object {
    return chickenProperty[property];
  }
}
var feathersPerChicken:Array = chickens.map(getChickenProperty("feathers"));
var weightsPerChicken:Array = chickens.map(getChickenProperty("weight"));

Reasonable attempt, but we might not always be dealing with chickens, feathers and weights. Lets go again.

function getProperty(property:String):Function {
  return function(item:Object, i:int, a:Array):Object {
    return item[property];
  }
}
var feathersPerChicken:Array = chickens.map(getProperty("feathers"));
var weightsPerChicken:Array = chickens.map(getProperty("weight"));

Thats more like it. However why do we have to get out the Array.map and getProperty when what we want is to pluck some feathers.

If we shuffle the code around a little we can forget about Array.map, getProperty, temporary variables, and iterator functions and say what we really mean.

function pluck(array:Array, property:String):Array {
  return array.map(function(item:Object, i:int, a:Array):Object {
    return item[property];
  });
}
  
var feathersPerChicken:Array = pluck(chickens, "feathers");
var weightsPerChicken:Array = pluck(chickens, "weight");

What if the Chicken.feathers property was an Array instead of a Number, how could we change pluck() to support the following?

var feathersPerChicken:Array = pluck(chickens, "feathers.length");

pluck() is available in asx and supports chained look-ups "propertyA.propertyB.length" and simple methods "property.toLowerCase()".

O HAI

2009-02-12T00:00:00-08:00

This is an obligingly brief first post.

It is about time I started talking about my projects, most of them ActionScript3 and Flex related. I’ll be showing lots of code about all sorts of fun stuff like mocks, testing, TDD, BDD, assertions, dependency injection, data structures, bytecode.