Wednesday 28 November 2012

Migrating SOAP client generation

After returning from a week long holiday, I have started into a new project at work.  Unlike the previous project, this one involves adding features and fixing bugs in existing code.

After setting up the development environment and an end-to-end analysis and explanation to a colleague of how the system seems to be making use of Spring MVC, we took a look through the POM files to get an impression of what components and versions are involved.

Based on experience from a previous job, I advised my co-worker that we might want to migrate away from using Axis 1 as it isn't actively developed (last release 2006).  After browsing between the official websites for Axis, Axis2 and CXF we returned back to the end to end POM checking.

A day or so later, my first development task for the project came through from the Berlin side of the development effort - replace the use of Axis with JAX-WS.

It's reassuring to be in a team that recognise the same candidates for improvement as I see.

On the technical side, here are some links to the resources that I found most useful:

Monday 19 November 2012

iPlayer not working - Adobe Air update to blame

Since a few of the search results that lead people to view this site appear to be related to my posts about BBC iPlayer troubles, here is another problem that I have encountered.

Before going on holiday outside of the UK, I tried downloading a few programmes on the iPlayer on my Mac laptop.  After a few seconds each download attempt would fail.

Fortunately this was a known issue, and the BBC site has a workaround:

Basically it involves uninstalling the currently installed version of Adobe AIR and installing an older version.

Sunday 18 November 2012

Is the cost of software development shifting?

I recently saw someone pull out an old statement that Maintenance is 80% of the cost of development.  I recall reading something similar in a software engineering textbook in 1996 - but a lot has changed in the way that we approach the development of software since then.

Here are a few key aspects of modern software development which should hopefully have shifted the balance:
  • Regular involvement of the product owner during development;
  • Frequent opportunities to observe and verify progress and change direction if necessary;
  • Regression tests built alongside the product to detect potentially unintended side-effects of later changes;
  • Routine review of code and configuration, either through pair programming or other electronically supported system.
Taking an unrealistic and strictly numerical approach to this, if the handful of things listed above double the cost of development but halve the cost of maintenance then the investment up front should be easy to justify.

(0.2 * 2) + (0.8 / 2) = 0.8
0.8 < 1

Of course all of this is completely open to speculation.  It could well be that the software products that are produced using the XP and agile approaches are more successful and result in a longer maintenance phase.

Wednesday 14 November 2012

Recursion - propagation of error state

Processing of an arbitrary depth data structure which has a parent or child relation hierarchy seems like a natural candidate for processing recursively.

Processing becomes more complicated when the operation could throw an exception, as we then have to consider how to handle the exception:
  • Should the exception be propagated?
    • Should the caller be expected to be able to reverse any previous state changes?
  • Should the exception be caught and ignored?
    • If so, should we continue to recursively apply the operation?
An alternative approach which may be useful in some situations could be to have a helper object which takes a copy of the outermost starting object and attempts to apply the recursive operation on the copy.  If the operation is successful then the completely transformed copy object can replace the original object.  If the operation was not successful then the original object would remain untouched and the information exposed by the failing operation could be made available to the caller.

I think this may count as a special case of the Unit of Work pattern, where the objects involved are actually part of one composite structure.

From String to enum in Java


In the last year or so I have been making more and more use of the enum support in Java to provide reverse lookup from Strings to obtain a value to use in a switch statement.


When iterating over the child nodes of an XML element with a known set of relevant node names and a corresponding process to perform on the differing child node content.

import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;

public enum DwarfNode {
BASHFUL("bashful"), DOC("doc"), DOPEY("dopey"), GRUMPY("grumpy"), HAPPY(
"happy"), SLEEPY("sleepy"), SNEEZY("sneezy");

private String name;

private static final Map lookup
new HashMap();

static {
for (DwarfNode nodeName : EnumSet.allOf(DwarfNode.class)) {
lookup.put(, nodeName);

public static DwarfNode lookup(String name) {
return lookup.get(name);

DwarfNode(String name) { = name;

The lookup method takes us from a String to an enum for any recognised name, which can then be used in a switch statement.

When we upgrade to Java 7 - or higher - we will be able to use a String directly in a switch statement, so this approach may become less irrelevant.