07 - 09 November 2018

M Shed, Bristol

Session type:
Tutorial

Session duration:
60 minutes

Presented by:

David Legge

Independent

About this Tutorial

Responsibility starts with yourself. “If you can’t manage yourself, you can’t manage anyone,” my Grandma used to say.

When something goes wrong, there are a number of ways in which you can respond.

The Dog Poop Initiative is a book written as if for children by Kirk Weisler. It describes a dog doing its business in a park and contrasts the common reaction of just pointing at the mess with that of someone who takes the lead by sorting it out straight away and scooping it up. It begs the question, are you a pointer or a scooper? Do you take responsibility and sort problems out, or wait for someone else to take the lead?

The 6 Stages of Debugging (a play on Kubler-Ross’s 5 Stages of Grief) describes different attitudes to the process of investigating a problem in software (or hardware), starting from “That can’t happen”, to “That doesn’t happen on my machine”, through to “How did that ever work?”. This gives us an easily imaginable demonstration of different levels of (not) taking responsibility, leading us to...

Christopher Avery’s book, The Responsibility Process, which outlines 7 stages of responsibility - and using debugging as an example, we will walk through each stage:

  • quit (can be reached from any other state)
  • denial
  • blame
  • justify
  • shame
  • obligation
  • responsibility
It’s referred to as a process because you can find yourself in any of the stages at any time, but the trick is to move your mental state to responsibility as soon as possible so you can deal with the problem.

The Responsibility Process is a tool for self-management only; if you try to ‘give’ responsibility and the recipient does not fully accept it, they can just end up in the state of (begrudging) obligation.

Taking responsibility is the only way to tackle a mess in a codebase; if you wait for someone else to sort out your mess, it will fester in the meantime. The Law of Entropy says that unless you actively work against it, disorder takes over your code, killing your project like the proverbial boiled frog. Is it going to be you that tackles it, or are you going to kick back and let someone else?

Leading by example will often mean others will start to take more pride in their work - and more satisfaction too.

As well as code, we can look at how to take responsibility for dealing with people. We will look at the Dolphin Behavioural Model, visually mapping 4 types of behaviour (passive, aggressive, passive-aggressive and assertive) and what kind of outcomes they look for. We can then show how you might deal with each of the types of behaviour - not that it makes it easy, but at least it gives you a shot.

The Dolphin Model allows you to recognise someone acting in a less than ideal way and then take responsibility for your relationship with them. The model provides a framework for how you might approach an encounter with them. It is tempting to just write them off. But by taking responsibility and making some effort, you can often turn around a difficult relationship and and build a constructive one - being more Dolphin is about seeking win-wins.

This session is about taking responsibility for yourself, which will be leading by example - when people see you act like this, it will build trust and encourage others to do the same, setting a professional standard.

About the Speaker

David is an independent agile software consultant and committed agile coder based in Cambridge. He has worked in just about every role within software and across all manner of sectors - public, private, education, research - and from food to finance - and agriculture to IoT.

 TheCodeCleaner

Tickets are available now

Buy tickets

See the full programme

Full programme