Agile velocity is not a measure of productivity

12 August 2013

Agile does not necessarily lend itself to management reporting. The few metrics it exposes are designed to support internal planning rather than external measurement. It can be tempting to re-purpose velocity as a measure of productivity, though this will only distort team planning without saying anything meaningful.

Managing change and version control for service interfaces

16 July 2013

Change is an inevitable and even desirable part of distributed development. Managing the impact of that change is the difficult part, particularly when change affects the service interfaces that bind a distributed platform together.

Netflix has abandoned OData – does the standard have a future without an ecosystem?

17 June 2013

Netflix have closed their OData catalogue and EBay seem to have quietly put their implementation out to grass. With a shrinking ecosystem and no marquee services, does Microsoft’s data standard have a future?

Sharing APIs in an organisation: challenges and pitfalls

4 June 2013

Sharing services and APIs can appeal to a desire to reduce duplication and improve development efficiency. It’s a worthy ambition though the journey there can be littered with costly traps for the unwary.

The generic repository is just a lazy anti-pattern

21 May 2013

A generic repository is often used with the entity framework to speed up the process of creating a data layer. In most cases this is a generalization too far and it can be a trap for lazy developers.

Writing a brokered messaging client for Azure Service Bus that is production-ready

22 April 2013

Azure’s Brokered Message API provides a basic set of methods that make it easy to start sending and receiving messages through the Azure Service Bus. The problem is that it doesn’t do much to provide some of the basic scaffolding required by a serviceable messaging client.

Using asynchronous log4net appenders for high performance logging

16 March 2013

Log4net provides decent logging performance out of the box, but you’ll need to consider asynchronous appending if you want more serious throughput or logging to a shared resource.

A shared database is still an anti-pattern, no matter what the justification

22 February 2013

Shared databases risk turning into performance bottlenecks that encourage close-coupling and create a single point of failure. There’s no justification for using them to integrate processes and applications.

Sharing code between geographically distributed development teams

15 January 2013

Large-scale development increasingly involves distributed teams as organizations seek to manage costs and leverage resources on a global scale. However, sharing code between distant development teams gives rise to problems that can only be addressed in part by processes and tools. You also need teams to communicate directly and build trust.

Build vs Buy decisions and the importance of context

8 January 2013

Technology decisions should not be made in isolation, particularly when you are trying to weigh up building a solution or buying a third party platform.

REST services may not have standards, but they should follow conventions

17 December 2012

REST is more of an architectural style than a set of standards. That said, a service should follow certain conventions if it is to be predictable and simple to work with.

Are CRUD methods what we really want from a repository?

6 November 2012

CRUD-based repositories may appear convenient but they can make for poor service interfaces as well as giving rise to a lot of unnecessary boiler-plate code.

How to manage down the payments on your technical debt

3 September 2012

Technical debt may be a great metaphor to describe the corrosive effect of quick and dirty design decisions, but it can be difficult to identify, measure and manage.

How not to use dependency injection: service locators and injection mania.

2 July 2012

Development teams can struggle with dependency injection, often because they don’t have a clear understanding of how best to use it.

Why refactoring code is almost always better than rewriting it

30 April 2012

Developers and architects like to build things, so their initial impulse is often to flatten the place, lay some stronger foundations and build something impressive. It can be difficult to get them excited about incremental innovation, even when this is generally the most sensible approach from both a technical and commercial perspective.