Software Engineering

Introducing Fidra: Monte Carlo Forecasting for Software Teams

Sun, 26 Oct 2025 10:00:00 +0000

Most teams I’ve worked with are asked to commit to delivery dates. The difficulty is that software timelines are uncertain, and a single-date commitment doesn’t capture that. When a team says “March 15th”, it’s unclear whether that’s a best case or a conservative estimate, and stakeholders will often hear it as a promise. Fidra is a tool I built to make these conversations more effective.

The Friction Matrix: Visualising the Cost of Tech Debt

Mon, 09 Jun 2025 21:01:00 +0000

This post outlines a practical, data-driven method for understanding how technical debt impacts upcoming deliverables. It helps teams and their stakeholders quantify where debt is creating the most friction so they can prioritise work to tackle it effectively.

Privacy Policy

Sat, 18 Jan 2025 00:00:00 +0000

This website respects your privacy and is committed to protecting your personal data.

Analytics

We use counter.dev for simple, privacy-friendly analytics. Counter.dev is a privacy-focused analytics service that:

Does not use cookies
Does not track individual users
Does not collect personal information
Only collects aggregate statistics about page views and visitor counts

Data Collection

The only data collected through counter.dev includes:

Page views
Referrer information
Browser and device type (aggregated)
Country-level geographic data (not precise location)

No personally identifiable information is collected or stored.

Analysing Subtitles with Natural Language Processing

Thu, 16 Sep 2021 12:24:53 +0000

A write-up of how we used Natural Language Processing at ITV to analyse how different topics are represented in our content through subtitles.

Link to article: https://medium.com/itv-technology/analysing-subtitles-with-natural-language-processing-4969071b9839

Building A Smarter Business With Event-Driven Architecture

Thu, 30 Jul 2020 10:41:00 +0000

Write-up of how we’ve used event-driven architecture at ITV to enable a data-driven approach to the content supply chain. By rearchitecting an existing message-driven, microservice-based system, we were able to introduce data and analytics capabilities without impacting feature development.

Decision-Making in Autonomous Teams

Sun, 28 Jun 2020 19:22:31 +0000

One of the most difficult aspects of a leader’s role is striking the right balance between giving direction and encouraging teams to make decisions independently. While experience may suggest that a particular approach is likely to be the most effective, it’s unlikely to be successful unless the team commits to it. There’s also a chance that better solutions exist, and given the right environment, teams will often discover these for themselves. Building that environment and providing their teams with just enough direction is where a leader really adds value.

Interactive Kotlin with kscript and fswatch

Sun, 31 Mar 2019 08:38:12 +0000

Experimenting with snippets of code and getting rapid feedback is a good way to get up to speed with a new language or library. I’ve been using Kotlin and Λrrow at work this week, so have been looking for tools that help achieve this workflow.

Worksheets in IntelliJ provide some of this functionality, but personally I prefer the immediacy of a text editor and the command line for this kind of thing. It turns out that kscript adds rich functionality to Kotlin scripts (e.g. importing code from other files, jcenter artifacts, etc.), and by combining this with the fswatch tool, we can approximate the basic features of a worksheet without the need to spin up an entire project or IDE.

Scala Central: Functional Design Patterns in Scala

Wed, 06 Jun 2018 20:05:33 +0000

Video recording of a talk I gave on functional programming at a Scala Central meetup.

Moving to a Startup: The Changing Role of Dev Manager

Fri, 05 Jan 2018 13:08:23 +0000

Moving from the corporate world to a startup can be an exciting and rewarding experience. As a technical leader, there is a lot to adjust to in terms of what the new environment demands from the role. That said, there are a number of valuable lessons that can be applied from the corporate world. Having made the move myself, I was invited to discuss this on the latest episode of the Venturi’s Voice podcast. Recorded in November 2017. Thanks to Andy Davis and the team for having me on the show.

Functional Design Patterns in Scala: 3. Monads

Sat, 30 Dec 2017 18:49:37 +0000

Learning (and subsequently trying to explain) monads has become something of a rite of passage in functional programming. Burrito analogies aside, the most helpful description I have come across is given by Noel Welsh and Dave Gurnell in Scala with Cats:

“A monad is a mechanism for sequencing computations.”

Functional Design Patterns in Scala: 2. Lenses

Sat, 24 Jun 2017 09:31:08 +0000

Case classes provide a convenient way of working with immutable objects in scala. Manipulating fields within them can be tedious, however. In this post, we will look at how lenses can be used to abstract over this complexity while preserving the benefits of immutability.

Functional Design Patterns in Scala: 1. Monoids

Tue, 30 May 2017 17:30:45 +0000

Monoids are used to describe an aggregation pattern: whenever we need to combine values of a particular type, a monoid instance helps abstract the mechanics of the aggregation from the program’s business logic. In this post, we will use the LCD Digits kata that we tackled previously as a motivating example for applying this pattern. The goal here is to transform a sequence of input digits into a string resembling their representation on an LCD display. For example, given the input 0123456789, the program should produce:

Agile Estimation For Distributed Teams

Mon, 15 Aug 2016 19:24:53 +0000

The teams I’m working with use Planning Poker to estimate the size of user stories. This has proved to be an extremely useful activity, and we rely on it to plan upcoming work. In the past, we used special card decks for this, which worked well when everyone was based in the same room. However, with team members now distributed across two continents, this quickly became less effective.

To address this, we initially tried running the sessions over a conference call, using group chat channels to record votes on the items being discussed. However, the quality of estimates noticeably deteriorated as a result, with less confident developers waiting to see what others thought before voting, and outliers not always being discussed. With distributed IT teams becoming more prevalent, a number of online Planning Poker tools have been developed. Since none of the available offerings quite met our requirements, I set about building our own. The key features of this version are:

Steve Reich’s Clapping Music with Akka

Thu, 31 Mar 2016 21:45:02 +0000

Using functions to express musical ideas is nothing new: Harmony, time signatures, the relations between notes in a scale and musical form all have their roots in mathematics, and composers have used mathematical abstractions for millennia (see Pythagorean Tuning for a 2500-year-old example).

These abstractions, however, are not always obvious from they way that music is written down, leading to a potential disconnect between composer and performer. In this post, we will use Steve Reich’s 1972 Clapping Music to show how functional programming can be used to capture an underlying musical idea.

LCD Digits Kata with Scala

Fri, 01 Jan 2016 16:41:39 +0000

I recently attended one of the coding dojos run by the London Scala User Group. It was great fun, and I’d recommend getting involved to anyone who’s interested in meeting other developers and learning more about scala and functional programming. After breaking into groups, we set about tackling the ‘LCD Digits’ problem from cyber-dojo.org. Although fairly straightforward as a programming challenge, it offers a number of ways to experiment with different functional idioms. The goal is to write a program that takes an integer, and formats this as a string composed of the ‘.’, ‘_’, “|’ and ” ” characters so that the output resembles an LCD display.

Turbocharge Your Mocking Framework With PowerMock

Fri, 16 Mar 2012 01:32:00 +0000

As mentioned in my last post, I am an ardent fan of the Mockito Framework. Originally developed as a fork of EasyMock, it equips developers with the tools to create mock objects using clean and expressive code. In this post, we will show how PowerMock can be used alongside Mockito (or EasyMock) to create mocks for classes that appear at first ‘unmockable’. Suppose we have the following class:

…which has a dependency on a DataProvider:

Using Reflection To Create Mock Objects

Fri, 07 Oct 2011 11:40:11 +0200

Well-established tools like Mockito and EasyMock offer a powerful range of features for defining and interacting with mock objects. I use both heavily in my unit tests, and would recommend them to anyone looking for a mocking framework. Sometimes, however, a real (i.e. non-proxied) collaborator is called for, or adding third-party libraries may not be an option. In most cases, a suitable object could be instantiated by calling the constructor and setting it as a dependency to the object under test. Suppose though that we have the following ‘Footballer’ class, and we want to write a test for the ‘getAvgGoalsPerGame()’ method:

About Me

Mon, 01 Jan 0001 00:00:00 +0000

I’m a technical leader and software engineer with experience in scaling high-performing engineering teams.

To get in touch, please send a message via LinkedIn. CV available on request.

Projects

Mon, 01 Jan 0001 00:00:00 +0000

Fidra

Monte Carlo forecasting for development teams: a tool to predict project completion dates using statistical modeling.

Try Fidra | Blog Post

Planning Poker

Agile estimation for distributed teams.

Blog Post | GitHub | Demo Environment