The Last Mile

How do you walk your software product through the wilderness of dumb users, dodgy machine builds and missing dependencies?

You want to reduce your support footprint and the dysfunction of dealing with false positives(i.e. it’s your software not my machine syndrome). If you have control of the deployment landscape then a standardised machine build and knowledgeable first line support come in handy. Otherwise online users forums and comprehensive user documentation will help share knowledge of work arounds, gotchas and technical Voodo. The last thing you want is for the development team to be constantly building patches to support all machines under the sun. Doing this robs the team of the precious time required to develop new features and enrich the product’s functionality.

Time and Tide and Software releases…

My team releases software every week regardless of the political landscape or inefficiencies of other departments. Ours is a disciplined and rigorous approach, we aim to be proactive and to keep the momentum forward, never backward. After all this is agile and we embrace the iterative and incremental nature of our game. To the gentlemen from the hydro-methodology this does not make sense. Surely you should only release when the business say so and when the business are ready for your release. If we did that then we would be constrained by the same inefficiencies that plague other teams. And that aint agile. So I suppose time and tide and software releases wait for no man.

Refactoring to a fluent configuration interface

The starting point was a configuration class that had the following definition:
public const decimal AdultFactor = 6;
public const decimal ChildrenFactor = 3;
public const decimal GasKwHMinEstThreshold = 4000;
:
These parameters are always used together in the context of a calculation for gas consumption. The client code uses these config values in the following fashion:

calculatedUsageKw = AdjustUsageForRadiators(calculatedUsageKw, GasConfiguration.AdultFactor,
                                            GasConfiguration.ChildrenFactor,
                                            GasConfiguration.RadiatorFactor,
                                            GasConfiguration.PersonsAtPropertyFactor);

I wanted to give the setting of the gas consumption parameters a fluid feel in the following style

public static IFluentConfiguration Create()
{
    var fluentConfig = new GasConfigurationFluent();

    fluentConfig.SetAdultFactor(6).SetChildrenFactor(3).
        SetGasKwHMinEstThreshold(4000).SetGasPointsMinThreshold(12).
        SetGasPointsToKwHConvFactor(400).SetGasWaterHeatingAmount(10).
        SetHobGasCooker(4).SetMainRoomFireOnGas(16).
        SetPersonsAtPropertyFactor(2).SetRadiatorFactor(5);

    return fluentConfig;
}

The client code accessing the fluent configuration interface was refactored to:

private decimal? AdjustUsageForRadiators(decimal? calculatedUsageKw, IFluentConfiguration fluentConfig)

The GasConfigurationFluent has setters that take the folllowing general approach:
public IFluentConfiguration SetAdultFactor(decimal? adultFactor)
{
    AdultFactor = adultFactor;
    return this;
}
And yes my setters have a return value which is in effect the current context i.e. my fluent configuration.After applying this refactoring, a few things became apparent,
1. The method chaining enforces the fact that these parameters exist in the same context and somewhat provides a cohesive view of my configuration interface. The setting of the configuration values is much more concise.
2. The cohesive nature of this configuration hints at the fact that a DSL(Domain Specific Language) could possibly be built around the calculation of gas consumption.

Wide laps

If the benefits of having a wide sturdy lap were ever in question, then look no further. On the left is my company laptop firmly glued to my thigh. The other limb is supporting my XPS M1330; looking on in the background is the Inspiron 1525.

Yesterday’s scrum

allocations app bindings build calculator client consumption data db encapsulation engine expiration factory gas getlatest googlemaps internal log4net loggin manual migrate mode pitching price process provider repository scripts service simple slow sourcesafe sqlmetal streetview subversion synchronization timeline update vss walklist webservice windows wireframes

created at TagCrowd.com

Dinner @ the inn

Yesterday was St. George's day and in celebration of the patron saint of England, I went to the local Inn where they had layed out the very best in English cuisine. This ranged from the curiously named toad in the hole to the delicious Shepherds Pie.

When Paradigms Collide- Sorting Spatial Data using the List Metaphor

Given a spatial dataset that comprises physical locations that must be traversed efficiently, what’s the simplest solution that would accomplish this task?

Trouble booting from CDROM on Sunblade 100.

Possible causes:

• Corrupted media
• Faulty CDROM drive
• Non-bootable media
• SunOS 5.9 limitations booting Ubuntu/Solaris 10
  

A lean view of scrum

The sources of waste are:

• Third-party delays in providing inputs required for the upcoming sprints
• Stories with insufficient detail to ensure that the team proceeds without interruption
• Scrum is yet to gain traction; the old way of doing things still haunts the project
• Delayed feedback
• Developer distractions – meetings; problems with machines; network connectivity; complex build process

NIH…

When a developer inherits a codebase, there is always a case of NIH(not invented here) syndrome. I am guilty of it, but with experience and professional maturity I have become more objective in my evaluation of third-party codebases. Recently, I had the chance to work on a codebase that ticked all the boxes of what a good software application should contain. The codebase exhibited the following characteristics:

• Unit testing and Mock objects
• Dependency Injection
• IoC Containers
• MVC
• N-tier architecture(and a slight hint of domain driven design)
• Fluent Interfaces
• NANT builds
• Code-generation
• Template meta-programming(generics)

These are fairly advanced concepts in software engineering and represent the software engineering zeitgeist. Unfortunately these practices will be lost on the majority of enterprise developers(unless you are working in a dedicated software shop that’s at the bleeding edge). For the typical enterprise developer, this translates into is software that is harder to maintain, extend and for which the sprint velocity is going to be dismal. The inheritors of the codebase have the additional task of understanding the domain and the engineering approach.

The question then becomes: how do you balance the need to create supple software systems whilst staying true to the software engineering discipline. Can you sacrifice the need for rigour in favour of comprehension and program understanding or vice-versa?

From XP Developer to ScrumMaster

As luck(or misfortune) would have it, I have been tasked with ensuring that the team delivers the right software on time and to the product owners’ satisfaction. My previous forays in extreme programming(XP) mean that there is zero cost of adoption of this new way of working. It could be argued that scrum and XP are polymorphic. They both inherit from the same agile shrub.

It is tempting to approach the scrum master role from a developers’ perspective given that I am a developer to the core. But this misses the essence of being a scrum master. I need to balance the demands of the product owner with those of the development team whilst being aware of the latent political interests that subtly influence the project. Some of these interests have a less than positive impact on the project and are impediments that need to be reported if the project is not to grind to a halt.

Agile is new to the organisation and the idea of product owners, sprint velocity, burn-down, sprints, product backlogs, sprint backlogs is alien in certain quarters. It is not uncommon to be asked to provide an estimate on the spot without consulting the team. My advice is don’t do it and don’t over commit the team.

Mobile blogging

First entry from Android G1. Mobile blogging is here...

HPC Windows Project back on track

After a turbulent winter, I have now resumed work on the beowulf cluster project. All my weekends and evenings for the next quarter are already spent. I wonder how I will sell this proposition to the girlfriend. Perhaps a chilvarous pitch might do the trick..."Darling, it's a climate change calculation engine..."

The next few weeks will see me configure the head node and install the SUN GRID ENGINE tools. Then the slave nodes will be configured and the obligatory benchmarking LINPACK tools will be executed to determine the cluster performance.