Mike MacDonagh's Blog

Somewhere in the overlap between software development, process improvement and psychology

Category Archives: Uncategorized

Chi Wai Kung Fu @ Cheltenham now with extra tech!

kung_fu_cats.pngFor over 6 years now I’ve been going to Chi Wai Kung Fu! A few years ago I achieved a lifelong ambition to become a Black Belt in Kung Fu. Now I’m a second Dan and a brown belt in Dacayana Eskrima as a bonus!

Chi Wai is great, my whole family go there 🙂
My two boys started when they were little and now are both black belts. It’s done them a huge amount of good, it’s far more than just self-defense (and that’s important by enough to justify it). They’ve learned respect, discipline, control, confidence and a positive attitude founded in the fact that they’ve worked hard at something to achieve their goals. me_sifu.jpgNot always achieving first time, but through persistence and hard work they’ve got there in the end! There’s a saying that a “Black belt is just a white belt that never gave up”, that’s something they’ve learned from Chi Wai.

My wife even does Kung Fu, and is heading towards her black belt this year. As a result I’m running out of wall space to hold all of our certificates. I’m also finding home practice sessions hurt a lot more!

The Chi Wai system mixes traditional kung fu with practical self-defence including weapons and group
attacks. Because the club has a full time dojo there’s lessons for separate age groups every day (except for Sunday, even ninjas need a rest).

It’s a great family run club with a genuine family atmosphere. It’s friendly and welcoming and manages to keep that positive environment consistently. A lot of that is down to the excellent instructors but it’s also down to the people and families that train there.

chiwai_family.jpgIt’s fantastic to have a family activity where we can all be at different levels, but all encourage each other and train together as the kids get older. As my eldest son’s gone from little kid to adult sized teenager he’s now fighting with the adults and enjoys putting me in arm locks in Black Belt lessons 🙂

If you’re in the Cheltenham, UK area then get yourself, your kids and your auntie to Chi Wai Kung Fu! You can even ask Amazon Alexa about it:

Or learn how to do the intro bow from my buddy the modelling guy:




Howto: Controlling LightwaveRF lights with a Raspberry Pi, Flirc and Logitech Harmony One IR remote

I’ve recently got into home automation and so thought it would be fun to integrate my smart lighting with my media centre and remote control. When I watch TV or streaming video I want the main lights to go off and the side/back lights to come on in my living room. When I pause I want the main lights to come up a little and when I play I want main lights to turn off again 🙂

My setup

I use LightwaveRF devices to control my main lights (2 dimmers) and various side-lights and screen backlights, I’ve also got a LightwaveRF Link hub which allows the Lightwave’d lights to be controlled by app, but also by simple UDP packets.

I’ve got a Logitech Harmony One remote control, because it allows you to setup custom sequences and controls my TV, DVR box and sound bar.

My solution:

I decided to use a Raspberry Pi 3 (now with Wifi and Bluetooth built in!) to do the lightwave udp packets and  Flirc to interpret the IR signals and convert them into simple text commands. Then I wrote a little python program that listens to the incoming commands from the Flirc USB Infrared receiver. There are other ways of interpreting the IR commands, but this was a super simple one!

Harmony One to Lightwave RF integration Read more of this post

Definition of done

Teams are sometimes split into smaller sub-teams. Almost always they are part of a bigger team, which in turn is part of a bigger team and so on and so forth until we reach the organisational entity. Don’t get me started on B2B teams.  Imagine an onion, with lots of layers. A weird mutated onion with multiple cores and overlapping onions. One that has tendrils sticking out into other similarly mutated onions like a big brain… Ok metaphor taken too far. Back to the topic…

The point is that everything team is connected to everything else. At every boundary it’s necessary to have a “Definition of Done” so that teams and their stakeholders understand what they’re getting.  Any good or otherwise set of software development practices (like Scrum, RUP, waterfall  or whatever you’re using) should help the team define the levels of their Definition of Done. I’m not using a specific example so I’ll just make some up off the top of my head to illustrate the point:

  • Fully documented, discs printed, shrink wrapped and online distribution site fully functional, support systems in place ready for users.
  • Beta test program
  • Acceptance Tested
  • Integration Tested
  • System Tested
  • Unit Tested
  • Code Built
  • Code written
  • Code designed
  • Idea thought of
  • Requirement captured

Given some levels like this we need to ask the question where do we draw the line? As an R&D team, as a component team, as an integration team or business team I’d expect different answers. And for those answers to vary according to points in the lifecycle and relationships between teams and stakeholders.

The point is that these different levels of done take different amounts of work and are intended to differentiate different levels of quality (although I’ve used a fair few public release versions of software that don’t appear to have even been unit tested!). Without working out what the definition of done is between teams or parts of a team no one can estimate, plan or deliver any work.

If you have problems with multiple teams working together in your organisation, a lack of understanding of the Definition of Done is one of the common causes and is relatively easy to fix.

Use Case vs. User Story

Use Cases are too big to fit into a sprint/iteration! User Stories are so fine grained there’s too many too keep track of! Where’s the big picture? How to we define releases? Argh!!! I don’t know which to use!

Personally I tend to use both. I don’t think there’s any conflict between Use Cases and User Stories, in fact they’re rather complementary. Here’s how and why….

A few years ago I delivered a presentation at an agile software development conference entitled “Do requirements still matter?”. The short answer was “yes”. Most descriptions of agile iteration start with having a backlog, prioritising etc. etc. But where does the backlog come from? My answer: the Backlog Fairy; obviously.

The Backlog Fairy

Of course requirements still matter, they’re how we get a common understanding between customers and development teams of what we need to do. They’re the units by which we can incrementally build systems. In the rush to adopt agile processes a lot of teams have forgotten that they still need to start up with some lightweight analysis of scope and risk.

One of the things Use Cases are great at is capturing the big picture, showing a simple diagram of stick people and blobs that people who’ve never heard of UML can happily discuss in terms of what big bits of functionality are in and out of the system and who’s going to do them. The humble Use Case diagram. Not so easy to do that with a massive list of small stories.

However Use Cases can often be a bit too big to fit into a single development cycle but since they’re made up of a lot of different scenarios they’re easy to slice up into smaller bits. This is where I often use stories.

The advantage of Use Cases defining the scope is they’re nice chunky things to estimate and prioritise in a first pass. Of course as we get going we’ll estimate and prioritise stories for sprints/iterations but Use Cases help us prioritise requirements into Releases.

So I use a Use Case diagram to describe the high level scope of the thing to be developed. This normally takes about 5minutes to sketch. Then I use the Use Cases identified by the diagram (not documents, just the ovals on the diagram) to focus discussion on deriving stories (or use case slices) for development and testing within a sprint/iteration.

Sometimes stories turn up that don’t really fit into the early Use Case model, this is a rather good thing as it lets us challenge the understanding of scope. Does the story not fit in because it’s not really in line with the customers priorities and needs, it’s a cross-cutting or architectural concern or because we’ve missed some important part of the scope? All are important things to understand.

An agile approach to innovation in a small company

I recently spent a little while thinking about an open, transparent and honest way to deal with innovation/staff objectives/supporting work in a small company. Note that this isn’t what my current employer does, just an idea for how these things can be done.

Firstly people need time to do this stuff, if it’s valuable for your organisation to spend time doing supporting work, intellectual property development or general innovation then they need the time to do it. People need the Google 20%. I’m very fortunate that in my job I get that time, or close to it normally.

New Ideas:

Create a wiki page or similar somewhere (that everyone can see and everyone can edit) – a bit like the Google ideas wall. Start it with a freeform/categorised ideas list in the form, this is a bit like a backlog, once an ideas done/delivered/published it drops off this list

Ideas – Owner – State:

Idea for doing something – Mike – Identified

Idea for taking over the world – Unassigned – Identified

If someone like one of these ideas they can run with it, recruit a team of colleagues if necessary and get on with it. Once I’ve asked someone to help with my idea I can be fairly sure they’ll ask for reciprocal help on something. This improves teaming in distributed companies and provides a channel for autonomous action, critical for motivation.

In Progress Ideas:

When ideas are in progress they’ll have their own tracking and information in the appropriate technology. For example a blog idea probably goes from being picked up to being published without any tracking. Maybe there’s a review process if it’s a big position piece so it might go through Identified to In Review on the list above but that’s it. Another idea might be for the development of some software, in which case it’ll take some time and probably have a project web and bunch of tools and info to communicate.

Complete bits of work:

Once something has been done the owner can add it to the achievements table, a column for each person where they can list what they’ve done with links to the various bits of output.

Person A Person B Person C
Blah Practice published Blog series on X
Paper published on Y

All bits of achievement aren’t the same size, but this allows people to see the creativity and production of their colleagues and find all of the useful things people have been doing. It also applies some peer pressure to Person C who on the face of it doesn’t appear to be adding much, although there could be a good reason for that.

Why did I say all this was agile?

Individuals and interactions over processes and tools

Individuals ideas are valued and encouraged, as are their achievements. People are encouraged to help each other and work together on ideas. There’s very little process and tooling involved, just a list on a wiki. If I had a co-located team I’d just use some whiteboard paint on a wall or some post-its.

Working software over comprehensive documentation

Well we’re not talking about software here, but achieving ideas. The emphasis is on the achievements table, not the detail of how people go there. In progress ideas can be tracked and reported using whatever info is relevant for the type of thing being done, which can be determined by the people doing it.

Customer collaboration over contract negotiation

This is an open and transparent process. Anyone can comment on the ideas on the list have a look at in progress ideas or question published/achieved goals.

Responding to change over following a plan

All this stuff is just written down, it would be easy to rewrite it if things changed. People, ideas, the environment etc. will all change so we need to be responsive to too and not plan the next 50 ideas to the hour.

Other thoughts

Since the list at the top is a bit like a backlog, it could be managed with input from management to direct the backlog, prioritise and agree. But I’d be wary of applying that kind of governance to creative/innovative ideas. I’m not proposing this as a general work management process, just an ideas/ancillary objectives process. Remember, bad management kills great ideas and worse this kind of management intervention stifles bad ideas, which are necessary and valuable.

Also, there are few things worse in life than an “Ideas Process”

The truth about motivation

The embedded video below has been doing the rounds a bit but I wanted to highlight it and draw out a couple of points as I deal with motivation of individuals, teams and of course myself. This video is from the excellent RSA whose laudable mission is

The RSA (Royal Society for the encouragement of Arts, Manufactures and Commerce): an enlightenment organisation committed to finding innovative practical solutions to today’s social challenges. Through its ideas, research and 27,000-strong Fellowship it seeks to understand and enhance human capability so we can close the gap between today’s reality and people’s hopes for a better world.

To summarise, money and bonuses have been shown by various studies to be terrible motivators for complex work. People need to be paid enough so they’re not worried about mortgages, paying for food and living their perception of a reasonable lifestyle. After that more money actually detracts from motivation. People are more driven by:

What motivates you?

Linux GUI Development: Monodevelop 2.6 review and screenshots

This blog is part of a series looking at programming tools on linux and covers MonoDevelop 2.6

MonoDevelop 2.6 is awesome 🙂 I first tried MonoDevelop about a year ago and gave up quickly. It just wasn’t usable, but these days it’s a totally different story. I’m quite drawn to Mono and MonoDevelop because I used to be a .net developer and really like C# as a language.  Also as an old Delphi developer the .net framework has an intuitive design and structure since they were both designed in large part by the same guy – Anders Hejlsberg. I saw him present on LINQ in LA, he’s a clever dude.

Mono is an open source project to make .Net compliant tools, compilers, runtimes etc. able to run not just on windows, but on linux, android, mac etc. MonoDevelop is an open source development environment for Mono providing GUI designers and language support for C#, Java, Boo, VB.Net, Python, Vala, C, C++, Oxygene (Object Pascal based .Net language, though not available in the current version of MonoDevelop).


I was able to install it directly from the Ubuntu Software Centre, it ran straight away with no issues. Not quite 10/10 though. I tried to write a “hello world app”  and  it wouldn’t compile 😦 A quick google later and I found that the default .net framework target in the project options needed changing from 2.0 to 4.0 then it was fine. 9/10

First Impressions

Starting up MonoDevelop you’re greeting with a very MS Visual Studio like welcome screen with links to create stuff, recent stuff and web links. The IDE has a very solid and elegant feel, it doesn’t start with a million views and tabs like Eclipse, is visually pleasing (unlike Lazarus) and incorporates platform theming well (unlike Eclipse/SWT). 10/10

MonoDevelop Welcome Screen

GUI Designer

The GUI designer is embedded in the main window in a similar fashion to MS Visual Studio, with widgets in a toolbox controlled by layout containers (fixed, aligning, tables etc.). Widgets are added to a window by drag and dropping and although there’s nice to have features like alignment guidelines missing the designer is solid, platform themed and doesn’t crash. It slightly frustrating to me that I can’t just double click on a button to create a default click handler and start writing my code but I can double click in the signals box (on the right) and do it from there.

MonoDevelop GUI designer

Brilliantly, it can handly some old c# .net forms I wrote which used custom visual inheritance to make a new form frame for an unusual app which I assumed would break it!

The only downside here is that many of the properties seem oddly named and aren’t consistent across different types. I keep having to hunt around for where to find the text property for different objects. There’s little relationship to WinForms either if you’re using GTK# in terms of property and event names. Oh yeah, and alignment/guide lines aren’t there yet when dragging components around.

Putting together a simple form is a trivial matter completed in seconds. 8/10

Code Editor

The code editor supports all the normal modern stuff like colour control, code folding, code completion etc. and again is neat and elegant. The code completion helper in particular is very easy to use as is the code snippets tool box. Obvious problems are underlined as you type and the link between the visual elements and code is easy to work with.

MonoDevelop - Code Editing

MonoDevelop - Code Errors

The only downsides for me are the refactoring interaction which features a visual arrow that jumps to suggested places to put the new code – it doesn’t jump to very sensible places sometime; the compilation errro/warnings which are shown inline embedded in the code. These can make it a little hard to read the code until you’re used to them. You can of course turn them off. Overall though, it’s excellent. 9/10

Language Features

Writing C# in mono is brilliant. From the mono project website:

The Mono C# compiler is considered feature complete for C# 1.0, C# 2.0 and C# 3.0 (ECMA). A preview of C# 4.0 is distributed with Mono 2.6, and a complete C# 4.0 implementation is available with Mono 2.8…

That means the language supports OO constructs, iterators, anon methods, generics, statics, extension methods, LINQ, memory management, reflection, threading and much more…

Between LINQ and the mono framework implementation of the powerful MVC pattern loading stuff into object graphs and presenting that in editable for to users is a high level programming exercise.

As an easy language example here’s  working with a collection of TestBlob entities:

private List<TestBlob> blobs = new List<TestBlob>();

StringBuilder sb = new StringBuilder();
for (int n=0;n<blobs.Count;n++)

Simplez! 😀


Feedback Process

There’s a little feedback button on the bottom of the IDE that lets you quickly send feedback to the community. I did this regarding my frustration over clicks from the visual designer direct to code handlers and another minor issue. Within the day I had a friendly response describing how my comments had been listed as two bugs on the public bug tracking system on xamarin.com and explaining how to add myself as a subscriber should I wish it.

MonoDevelop - Feedback

That’s awesomeness on toast! 10/10


The solid GUI designer, integrated debugger and high level language support for cross-platform development provided by MonoDevelop is brilliant. It’s easy to knock up a quick app to do something. My 7yr old son and I have been using it do develop a calculator as an introduction to programming basics and he things it’s a good easy to use system.

Getting going with the MVC pattern can be a little frustrating if you just want to programmatically put a bunch of things in a listview (btw if you do this use a treeview not a listview even if that sounds crazy at this point) but that’s a common hurdle for most modern day languages/gui widget sets.

The mono and monodevlop communities are large and active and the web is full of c# tutorials and info. I’ve found that guidance written for MS developers in c# is directly applicable to c# in mono. This is now my favourite cross-platform development environment and technology.

Category Score
Installation 9/10
First Impressions 10/10
GUI Designer 8/10
Code Editor 9/10
Language Features 10/10
Feedback process 10/10
Overall 93% – Excellent

Automatic bidirectional synchronisation between RTC and ClearCase

I’ve previously blogged on a manual ClearCase to RTC migration script I use during migration from IBM Rational ClearCase to IBM RTC. However sometimes it’s necessary to consider automatic synchronisation for the following reasons:

  • Partial team adoption in large teams/organisations
  • There are code dependencies between teams (you’d be better off breaking them to binary dependencies and using something like maven or ivy though…)
  • Support teams on RTC SCM while interacting with content from ClearCase multisite locations
  • Maintaining complex builds that are dependant on ClearCase (i.e. using ClearMake).
  • Allowing teams to pilot RTC SCM without working about branching between tools
  • …. and many more…

The off the shelf offerings to bridge between RTC/ClearCase are a bit limited due to the relationship between eclipse projects, rtc components and streams. It’s necessary to have eclipse projects at the root of a component for them to load smoothly as proper projects in eclipse with their correct natures, so any serious synchronisation solution needs to allow you to pick and choose parts of a folder structure in ClearCase and sync them to projects in components in RTC. The excellent open source RTC ClearCase workspace synchroniser from samecs does exactly this.

I personally use a combination of the manual migration script (mentioned at the top) and the RTC ClearCase workspace synchroniser to deal with team migrations from ClearCase to RTC. Generally my preference is to do it manually as synchronisation is a tactical solution during rollout and introduces a fair amount of technical complexity, but in cases with the features mentioned above sometimes you need a powerful and flexible synchronisation solution.

RTC: How to write cross project queries

Ok, so I’ve previously said that you can’t write cross-project work item queries in IBM Rational Team Concert but that’s not entirely true… You can, but it’s a bit “hacky” and isn’t very supportable. In Eclipse go to:

Team Artifacts -> My Team Areas node, select a user -> right click -> Show Recent Work

This seems to create a work item query that has the user as a top level scoping element rather than the Project Area, you can even add the Project Area column to the result set 🙂 You can edit this query in the normal way but it seems to save itself to a project area selected by rolling a dice and there’s no way to control which one as far as I can see. Also, remember that it’s top level scope is the user that the query was generated from, that may have interesting effects.


Don’t forget to demand proper cross-project querying from IBM on jazz.net

Edit: 10/11/2014 – to choose which project area the hacky query ends up in simply disconnect all of the other projects areas (and restart eclipse).

How to migrate source to Jazz RTC SCM

First of all, although it might seem tempting to seperate scm and build, especially from a business change and planning perspective you just can’t (unless you’re writing scripting languages!). Software is just useless text if it can’t be built/run and a software team can’t be expected to move where they store their source without ensuring that build doesn’t get broken. In a perfect world build scripts would be generic and work regardless of the scm system they’re coming from but that generally isn’t the case due to this not being a perfect world:

  • different scm systems/ides imposing different structural constraints
  • absolute paths to files
  • dodgy use of symlinks
  • lack of parameterization of build scripts
  • complexity of numerous build technologies

This means that when migrating a team into Jazz SCM you need to at least ensure that their current builds work in their current normal way. Ideally it would be great to (re)engineer them to word with RTC Build but that isn’t always practical. This build refactoring shouldn’t be underestimated as it can take a while because of general build complexity, project complexity and technology complexity. It’s not unusual to find in just one organisation the use of: ant, maven, junit, ivy, make, clearmake, msbuild sometimes all on the same “project”. Add unit testing, style checking, static analysis and other things that people tend to add into the build process and you’re looking at a large amount of technical skill needed to even begin to make sense of what’s currently going on.

For this reason when moving a team from cm system X to RTC Jazz SCM I find it necessary to build the stream in 2 parts, which means you need a repeatable migration script that doesn’t get tripped up by things like permission or line end delimiter platform differences.

My general migration script (assuming not synchronizing or bridging):

  1.     Label/Baseline/Shapshot source files in old scm system
  2.     Using linux copy source files from existing scm/view/folder to a holding area
  3.     chown if necessary and chmod files to u:rw(x),o—,g—
  4.     I tend to do a dos2unix conversion on appropriate files to normalise mixed mode files
  5.     Share to RTC
  6.     Baseline/Snapshot in RTC
  7.     Make builds work (generally a process of changing absolute path references to local relative paths – often “/view/blah/…/proj” to “../” (here be technical complexity)
  8.     Baseline/Snapshot in RTC (“Initial scm migration with working build”)

There is a great advantage in following this process (which is why I’ve scripted steps 1-4 although unfortunately I can’t share that) somewhat slavishly in that it is repeatable to update a file set as a change set. If you do this to create an example stream for a team to experiment and gain confidence in while they’re still developing in their existing system, then when they choose to adopt you can simply update their stream(s) by:

  1.     [Optionally] revert to working build snapshot “Initial scm migration with working build” from step 8 above
  2.     Repeat steps 1-4 above
  3.     Copy files in holding area to RTC workspace
  4.     In RTC Pending Changes view drop-down the refresh button to select “Refresh Sandbox and Remote Changes”

You then get a change set showing the file changes since the experimental migration and the present time, simply undo or merge changes to build files to retain local workspace references and then deliver to update RTC using an atomic change set(s) 🙂

%d bloggers like this: