Code Kata – Conflicting Objectives

This month, we’re on Code Kata – one from PragDave’s collection (

Why do we write code? At one level, we’re trying to solve some particular problem, to add some kind of value to the world. But often there are also secondary objectives: the code has to solve the problem, and it also has to be fast, or easy to maintain, or extend, or whatever. So let’s look at that.

For this kata, we’re going to write a program to solve a simple problem, and we’re going to write it with three different sub-objectives. Our program is going to process the dictionary (word List) and looking for all six letter words that are composed of two concatenated smaller words. For example:

al + bums => albums
bar + ely => barely
be + foul => befoul
con + vex => convex
here + by => hereby
jig + saw => jigsaw
tail + or => tailor
we + aver => weaver

Write the program three times.

• The first time, make program as readable as you can make it.

• The second time, optimise the program to run fast fast as you can make it.

• The third time, write as extendible a program as you can.

Now look back at the three programs and think about how each of the three subobjectives interacts with the others. For example, does making the program as fast as possible make it more or less readable? Does it make easier to extend? Does making the program readable make it slower or faster, flexible or rigid? And does making it extendible make it more or less readable, slower or faster? Are any of these correlations stronger than others? What does this mean in terms of optimizations you may perform on the code you write?

‘The Agile Method’ & a discussion: Big/Distributed Teams

We’ve re-branded ‘data processing’ as ’computer science’, ‘software engineering’, ’informatics’ and ‘software craftsmanship’. Is agility a return to software development as Real Science? Would Aristotle recognise our PROCESS?

Followed by “a heated debate” (with Andy Woo’ as Mrs. Merton):
As small teams grow or split across multiple locations, can we hang on to our Lean / Agile values? How?

Contract Testing, or how to obtain reliable, integrated, isolated microservices.

Change of plan!!! So, unfortunately, Andy can no longer make Thursday so we’re going to deep dive into contract testing…

Part of the attraction of microservices is the ability to distribute the development effort of a large system into isolated services that can be owned by autonomous teams. This isolation allows teams to use appropriate technologies, and development approaches that work best for the team and problem domain.

Each time might have differing release schedules, and development dependencies between teams can cause delivery bottlenecks, and undue stress. 

Rather than attempting to further align the teams schedules, an alternative apporach is to focus on the contract between the services  – the interface. If this can be agreed, and specified using contract tests, then the consumer and provider teams can iterate independently. The contract tests will pick up integration issues, and can be used to provide test doubles for the consumer. 

In this session, Paul Williams will describe the approach, pros and cons and a attempt a group experiment to demonstrate how this approach can support agility in large integration projects. For those technically minded, please bring in laptops with a development environment suitable to develop / consume basic http services in any language. This is not a requirement however, and non technical attendees should hopefully leave with an appreciation of the benefits of this approach.

The guilded rose kata

So, after unfortunately missing a December session, the last Thursday of January sees us revisit the Guilded Rose Kata. It’s a language agnostic session so bring your laptop and have some fun with the challenge to refactor code for maintainability.

Happy Birthday, and how’s agile changed in your life time?

Happy Birthday Agile Staffs – 5 years! It’s been emotional…

From those early days at the Pie and Ale with Paul Shannon, Neil Kidd and countless regulars that have come and gone. Even 5 years ago agile software development was little known in the Midlands.

We went through a struggled phase a couple of years ago with only around 3 attendees at sessions but we’ve recently been able to increase membership and have enjoyed some great sessions.

I’ve suggested this session should be an open discussion about how agile has changed in these times. Is it more popular than before? Is the manifesto still relevant, and being used to affect software development, or are we just cargo-culting? Stand-ups for stand-up sake, not actually delivering each iteration, not taking notice of WIP? What can we do to make sure Agile Staffs still here in another 5 years?

We should wrap up a little earlier than usual, and finish the birthday celebrations at the Knot and Plough around the corner.

Functional Programming with Clojure

Functional programming has previously been seen as a niche, academic form of programming with little use in popular commercial software development. With greater system resources available on modern computers, and multi-core processors encouraging emphasis on multithreading, functional programming is back – and here to stay.

Paul Williams will initially demonstrate simple functional programming concepts like immutability using the Clojure REPL. He will walk through options on getting a Clojure environment working, but clojurerepl is an equally good environment in which to try the language with no setup. If you want to install Clojure, please ensure you have a modern JDK installed.

Once people have basic familiarity with the language and REPL, he’ll present some of Clojure’s time / noise saving features like destructing, and map / reduce.

Many OO / imperative programmings understand the benefits of FP, but don’t see how an application can be written with immutable state – Paul will finish off with a quick demo of a simple system written in ClojureScript / Clojure with an immutable database – Datomic.

Web Applications with CakePHP

As August’s session didn’t get off the ground, I will present what was to be the second half of August’s session as a full session in September.

Details to follow. This will be a practical session, so bring your laptop. The language will be PHP.

Collaboration Review & View Testing with PHP

August with Agile Staffordshire will comprise two strands of concern. Firstly, we shall take some time to explain our external activities this year and share the value they have had in our practice. I will start the session with a review of the BCS SPA 2015, a conference that I attended at the end of July.

Additionally, as a show & tell exercise, I will follow on from Ruth Mills exceptionally interesting session last month by demonstrating something similar, but probably not as good! We can tear the process of testing views in web applications and apply it to software development at large.

I look forward to seeing you there!

P.S. There may be a room change with appropriate software available so that everyone may have a go easily. I will post updated information if appropriate.

Thymeleaf and Thymesheet

An introduction to the Java templating engines Thymeleaf and Thymesheet, and how these can be used in Agile projects in conjunction with Spring and Maven. This will be a hands-on practical session with examples you can go through on a Java IDE of your choice (e.g. Eclipse, STS or IntelliJ IDEA).

Agile Book Club

This month we are hosting a book club of sorts. We are opening the floor for our members to share highlights, give an overview, or empart something learned from book you’ve read recently or perhaps something that has stuck with you and had a positive impact on your programming or the processes you follow. The format will be informal 10 minute lightning talks with a projector, whiteboard & an audience. If you’d like a spot to talk, please get in touch on meetup, twitter (@AgileStaffs) or email (

Hope to see you there,

Tag Cloud