When you introduce agile methods to very traditional organisations there’s a side effect most people underestimate. This is, I believe, where the first line in the manifesto is most appropriate:

Individuals and interactions over processes and tools

Traditional organisations are geared for efficiency – keeping individuals busy to the point where you lose overall effectiveness if you ever need to synchronise between parts (which you inevitably do for software these days). Calling a meeting is frowned upon as it takes up lots of time, so out of necessity, most communication occurs over email or IM. As Alistair Cockburn pointed out a long time ago, these are pretty ineffective channels of communication. Relying solely on these types of channels only turns to a build up of frustration as issues go unheard by the right set of ears. In traditional environments, these often turn into build ups set to explode at the most random of moments.

Image from Nic Jacka’s flickr stream under the Creative Commons licence

Perhaps you’ve seen it? Think about when one person hijacks a meeting to highlight an issue (typically important one) not being addressed, or when someone spontaneously shouts at someone for no apparent reason. It might even be as bad as someone having a temper tantrum, literally throwing things across the room. Traditional environments often do not provide mechanisms as outlets for this.

Therefore, when introducing practices such as daily stand ups, planning meetings and retrospectives, the first few times you run them, expect an avalanche of unresolved issues and emotions to ensue. This is fine. Expect this from some of the quieter members as you give them explicit permission to talk about important things that need resolution where traditional structures have not given them that permission to talk about them.

Treat it as you would the opening of a previously shaken soft drink bottle for the first time. You’ll have to be ready to clean up some of the spilt liquid, but you don’t have to worry about picking up broken glass. Now that the bottle’s open, you can work to address the real issue at hand.

I first read “A Community of Thinkers” that Liz, Jean and Eric published late last year. I remember thinking that I felt strongly aligned to it, yet slightly uncomfortable with the exact wording. I toyed around with some words and now, a couple of months later, I am much more comfortable with a slightly abridged version.

It isn’t enough to be a member of a community of thinkers. We can philosophise and think ourselves to death. The world continues to operate in complex ways (yes, as in this, and this sort of complexity). It is not enough to sit back and only think. We need to experiment. We need to apply. We need to practise, then reflect and feed those learnings back into our thinking. This is the essence I respect the most about certain people in the agile community. This is what I want to keep alive. Remind yourself the Do is an important part of PDCA just as much as Check (Reflect) is.

For me, I am not just a member of a community of thinkers. I am a member of a community of thinking practitioners. If you’re not practicing and actively thinking, you’re not part of my community.

A Community of Thinking Practitioners
I am a member of a community of thinking practitioners.

I believe that communities exist as homes for professionals to learn, teach, and reflect on their work.

I challenge each community in the software industry to:

• reflect and honor respect the practitioners who make its existence possible;
• provide an excellent experience for its members;
• support the excellent experience its members provide for their clients and colleagues in all aspects of their professional interactions;
• exemplify, as a body, the professional and humane behavior of its members;
• engage and collaborate within and across communities through respectful exploration of diverse and divergent insights;
• embrace newcomers to the community openly and to celebrate ongoing journeys; and
• thrive on the sustained health of the community and its members through continual practice, reflection and improvement.

I believe that leaders in each community have a responsibility to exhibit these behaviors, and that people who exhibit these behaviors will become leaders.

I am a member of a community of thinking practitioners. If I should happen to be a catalyst more than others, I consider that a tribute to those who have inspired me.

This one is based upon the original posted on Liz Keogh’s blog here. This licensed under the Share Alike Creative Commons License. All modifications/addendums I made are emphasised in italics.

I’ve been a big fan or Real Options since I heard about them a few years back. It gave me a better way of calculating the Last Responsible Moment. I look at decisions very differently now, recognising when we need to make decisions now, and when we can defer those decisions until it is too risky to make them.

Looking at the agile toolkit of index cards and sticky notes, I’ve come to realise using these during facilitated discussion is a great way of implementing real options when it comes to organising ideas.

Compare this situation:

Situation 1: The team sits in a room with a facilitator helping the team brainstorm ideas to a problem they have. As a team member thinks of an idea, they call it out, waiting as the facilitator kindly writes it up on a flipchart using a permanent marker. The facilitator then looks at the flipchart, inviting people to make observations. They comment about seeing a pattern, so the facilitator uses a different coloured pen to start drawing lines between ideas. They try crossing out ideas, rewriting them closer to places that seem more relevant. As more discussion ensues, the board becomes covered in more lines, rewritten words, and the facilitator becomes flustered with people changing their minds all the time. Out of frustration, the facilitator stops the group and asks them to make up their mind for the final time.

Situation 2: The team sits around a table in a circular format, each with a pile of sticky notes and markers in front of them. As each person thinks of an idea they write it down on a single sticky note and put them into a pile. The facilitator takes the sticky notes, and starts to arrange them on a wall. The team notice a pattern, moving certain sticky notes closer to each other. More discussion ensues and everyone suddenly helps moving, grouping, sometimes ungrouping ideas as they experiment to best find how the ideas relate to each other. The facilitator stands back at the end of it, and takes a photo to share as the outcome of the meeting.

Deferring commitment using sticky notes
I love using index cards and sticky notes as they let you capture ideas and move on before needing to classify, categorise and relate them to each other (somethign you can spend a lot of time on). They let you experiment cheaply seeing structures in the ideas by moving them around. Rather than being restricted by a piece of paper (flipchart), your only restriction on experimenting is the time you spend on rearranging and looking for patterns. Sticky notes (or index cards) allow you to defer the commitment of linking ideas together in a model. In my experience, even if you substituted a whiteboard, you spend more time rewriting (recapturing) ideas than finding ways to relate them to each other.

Thanks to all the people who came along to the GeekNight Liv Wild and I hosted last week. We’ve put the slides up online here.

I hear about two major approaches to introducing agile methods to organisations. Kaikaku (known in lean circles as radical change) is the brute force method of pushing all the change you want upon the organisation. You recognise this when basically the “normal” way of working is flipped on its head and a whole swarm of new practices are introduced.

Kaizen (known in lean circles as continuous improvement) is the softer, gentler approach to change, tweaking one bit here, and one bit there. Think of this as a way of introducing a single practice a time.

Now that we are clear about what is what, comes the interesting question of what is better?

You seem to be faced with two choices. A radical change that seems like a high chance of failure, but could also be a huge success, or smaller incremental change to do this.

In order to answer this question when I join a new team or organisation I like to consider how much their environment supports them in what they want to do. Those with supporting, nurturing or safe environments I would probably head towards Kaikaku, using education and building trust with senior stakeholders to establish longer term safety. You can increase safety and reduce the likelihood of failure if you can bring in a high proportion of the culture you’re looking for. I’ve seen this succeed really well when you have at least 50% of a team with lots of agile experience, something you tend to have when you hire someone like ThoughtWorks.

Work with less than 50% experience mixed support, and you start to decrease safety. At this point, I would start to look towards kaizen methods of improvement. Of course there are many levels at which you might apply kaizen and kaikaku, but consider safety levels when doing so.

More interesting developments as @carlton858 points out there doesn’t seem to be a Professional Scrum Master certification announcement on the home page of Scrum.org anymore.

Fortunately I still had a copy of the page as it looked yesterday below:

Here’s what google’s cache of it had several days before that:

And here it is today:

I’m intersted to see what future developments occur in this Scrum world. Here’s the original PSM announcement. (bearing in mind it’s probably going to change or not be relevant when it comes back up)

The split in the Scrum community with Ken Schwaber going independent of the Scrum Alliance sees Scrum.org announce the Professional Scrum Developer program.

An interesting development indeed. There’s also now a competing certification for the Professional Scrum Master instead of the Certified Scrum Master. I’m sure this is going to be confusing for everyone. (I wonder if that means Certified Scrum Masters are then implied as Unprofessional as a result?)

A few weeks back, Andy and I got together to walk through all the different iPhone examples that we’ve been playing around with. We both learned a great deal.

I’ve found that teaching whilst learning is actually the most effective way of learning. There’s something about trying to put words to the things that you think you know that makes you reason actually how little you really know.

I think the best learning model where this experience fits in is the following model:

Unconscious Incompetence -> Conscious Incompetence -> Conscious Competence -> Unconscious Competence

The act of trying to explain something is trying to raise you from one level to the next. If, for instance, you think you know what you’re doing and then find yourself having difficulty explaining something, you’re perhaps you are at a stage of Unconscious Incompetence. However if you know you are already incompetence (Conscious Incompetence), then the act of explaining is helping your understanding, testing the boundaries of where your knowledge fails. You are trying to move from Conscious Incompetence to Conscious Competence.

Interestingly, articulating your competence (or lack of) is an integral part to both a software craftsmanship model and pair programming, where in both you are expected to articulate your reasoning. The benefits work at all sorts of levels including the novice-novice and even the expert-novice pairing arrangement.

Conflict is a natural part of your every day life, whether it is at work or home. A certain amount of conflict is healthy as long as you work out how to resolve it.

Liv Wild and I will look at a number of conversation models we’ve found healthy teams use, in agreeing to agree. We’re holding it at the Thoughtworks UK office from 7pm this Tuesday (9 Feb). More details can be found here.

Last year, I ran a workshop at XP2009 and Agile 2009, helping people map behaviours to the different levels in the Dreyfus Model. Being a workshop for only 90 minutes, we only had time to introduce the model, generate a set of behaviours mapping them to each level in the model and only a small fraction of time thinking about where this might be useful in a coach’s toolbox.

I tend to use it as a way of encouraging people to self-assess their own behaviours, and as a way of seeing concrete, specific sets of behaviours that people in more advanced stages might find themselves.

We didn’t really get an opportunity to discuss the limitations of using the model in this way (remembering that all models are inherently limited in some manner).

Most useful for Novices
Ironically enough, this set of behaviours mapped in this way is only most useful to those who still remain Novices and less so, the Advanced Beginner. Novices need concrete rules, and directions. Advanced Beginners start to see context, yet it’s often helpful being specific about what sets of behaviours you might see at different stages.

Ironically, as you progress, using the Dreyfus Model in this way becomes less useful as you progress. I like to introduce this set of behaviours after people have had some experience with a certain practice. It helps people answer the question, “What does good look like?”

It’s not an exhaustive list
When I’ve run these workshops with other coaches, I find it interesting to see how they notice different sets of behaviours from what I would observe. Even when looking at a single practice, you have a multitude of behaviours at lots of different levels. It’s preciseness at describing specific sets of behaviour also has the risk of people only focusing on the prescribed behaviours instead of thinking about the sorts of behaviour that sits at this level.

I can’t imagine trying to list every single set of behaviour. As interesting as that might be, I think it would be impossible to capture, and difficult to communicate succinctly.

Best for personal development, not as performance evaluation criteria
It’s easy for managers to see a list of different levels, and then attempt of fit people into a box for performance evaluation. As much as their intention might be good good (professional growth) I think it’s easy to game.

I like to emphasise that this model is best used as a way for coach’s to help people self-assess, and for people to set their own goals about where they want to be.

Not the only tool to use
I like using this tool as a transitional tool, helping people jump the gap from Novice to Advanced Beginner and from Advanced Beginner to Competent. Beyond that, I would use less of this tool and look at other tools that help people self discover their information.

Update: Posted this so early my brain wasn’t awake and I hadn’t linked to the feedback links as promised. I’ve updated it so that it’s correct now.

A few people have arrived at this blog looking for the terms, “Giving feedback to defensive people.” Before focusing on the fact that the recipient may be “defensive”, I’ll refer to you to several different posts outlining some principles of giving effective feedback. Read them before continuing on.

Firstly, if you’re giving feedback to a person, ensure that you follow the principles of effective feedback.

1. You intend on strengthening their confidence; or
2. You’d like to help them improve their effectiveness

Many times I’ve heard several people give feedback and it is not in the spirit of either of these. Often, they give feedback with the intent of improving their own effectiveness, not necessarily the recipient. For a variety of different reasons, it’s easy for me to improve my own effectiveness by asking people what to do – something that is both selfishly easy. It takes more courage and effort, putting yourself in the recipient’s shoes to help them out.

If someone comes across as “defensive”, I’d ask yourself what circumstances they could possibly under that make them so. Perhaps they have other things on their mind, and are preoccupied in a manner that makes it difficult to listen to feedback. The solution? Ask them if now is a good time to give them feedback.

Maybe the recipient associates “feedback” with “criticism” due to others “giving them feedback” ineffectively, fuelling a cycle of defensiveness. The solution? I find it easy to spend a quick minute or two describing the basic principles of feedback, and help them understand you are here wtih the true intent of either strengthening their confidence or improving their effectiveness. I like to emphasis it should be a conversation and that I will try to be a specific as possible, but encourage questioning if the recipient needs clarity.

Another reason the recipient may be defensive is for fear of being judged as a person. The solution? Focus on behaviours and impact, rather than attempting to describe what you think their motives are. This doesn’t mean you cannot have an opinion, however it should be clearly stated about how you interpret the impact, not on how you interpret them as a person.

They may truly believe that whatever situation you describe, they disagree with. The solution? Start with the model I describe here, seeking agreement for observations, then impact, before thinking about recommendations. Any disagreement on the early stages will inevitably lead to disagreements on future stages.

Finally, as a person giving feedback, you need to accept the recipient may choose to acknowledge, disagree with or do nothing with the feedback you gift to them. I remember one incident, quite recently, where a colleague gave me feedback with recommendations. We talked about it, both understanding the variety of forces unbeknownst to each other. At the end of the conversation, I concluded I would have repeated the same behaviour in the same circumstances, however that’s when the feedback donor got frustrated. My lesson, if you’re giving feedback to someone, be prepared to say, “I respect that we disagree on something, and thank you for being prepared to listen.”

Andy wrote a great blog post trying to relate Shu Ha Ri to the Dreyfus Model of Skills Acquisition. When I posted my thoughts, he suggested I blog about my story, so here it is.

In it’s simplest form, Shu -> Ha -> Ri roughly translates to Follow -> Detach -> Transcend. When I think back to the days when I studied Aikido (where I believe these concepts originate), I considered Shu Ha Ri as the flow of energy, or where you focus the majority of your efforts.

Photo of energy taken from HocusFocusClick’s Flickr stream under the creative commons licence

A Shu person, for example, focuses their energy on simply executing a very basic move. They repeat the kata, over and over, with the weight of their conscious mostly on thinking, “I move my arm up to block”.

The Ha person, no longer follows the rote kata, “detaching” from the original conscious thought, now focused on its application. They spend their time thinking, “An arm is coming my way, I better block”.

The Ri person is certainly spectacular to witness with energy flowing from move to move, something the dojo sensei demonstrated during a yearly open house. During this event, lasting a good twenty minutes, five black belt students attacked the sensei from all sides. They attacked with their hands and a small assortment of weapons. The sensei defended by turning, locking and throwing each student back in return. What I still remember vividly was comparing the black belts, completely drenched to the skin in sweat, to the sensei, who barely showed any signs of sweat.

I see this same flow of energy and focus of effort when watching people learn development skills. At one end of the spectrum, the Shu developer spends an enormous effort thinking about how to execute a particular practice. At the other end of the spectrum, the right practices occur and great quality code (and tests) appear.

Thanks to all the people that came along to the BSC London presentation I gave last Wednesday. Despite the threat of weather potentially cancelling our, previously snow-canned, presentation, it went ahead much to my delight. I hope that you all got something out of it. I’ve uploaded the slides here if you’d like it.

As I gather more experience (i.e. get older) I’ve discovered every model has a breaking point. What does that mean and why should you care? Accepting that models break is the first step to understanding and identifying their limitations. More importantly, because models have a breaking point, you should be actively discovering other models that help you better communicate and grasp new concepts.

Sounds easy right? Unfortunately my experience in life proves the opposite with most people wanting to only hold a single “valid” model that manages to explain and justify everything. I see this as a consequence of western education guided by Socratic thought and a Platonic ideal but that is a post for another time. In real life, this desire to hold onto “one valid model” translates to arguments over the merits of a particular model and often the basis for justifying a position. Note that I have no problems arguing for the sake of testing and discovering the boundaries of a particular model.

What do you do about it?

Accept that models are simplifications of sometimes complicated, sometimes complex systems. Be open to exploring the boundaries of a particular model, uncovering where one model excels at explaining certain characteristics of a system. Seek out and invent new models that provide a different point of view, or that emphasise and highlight different aspects for that system.

One of the biggest differentiators between the users who prefer IntelliJ over Eclipse is often their dedication to learning keyboard shortcuts. The user-conscious designers of IntelliJ make as much as they can consistent, something much more difficult for Eclipse, who is dependent on a community for plugin development without any process for reviewing how well they all fit together.

On my very first ThoughtWorks project, I remember my pair commenting about how I should learn all the keyboard shortcuts for IntelliJ. Learning keyboard shortcuts is less about churning out great amounts of code, and much more about avoiding interrupting your flow. Simple actions, such as reaching for mouse have potential to break your flow. Jetbrains make it easy to learn the keyboard shortcuts, even providing a printable cheat sheet so you can put them around your workspace as you learn them.

Having said all of this, here are some of the keyboard shortcuts I find myself using all the time for iPhone development:

• Switch to Header/Source File- ALT + CMD + UpArrow
• Open quickly – Shift + CMD + D. This is as close to Jump to Class/Method/Symbol that I could find so far. I haven’t worked out how to search using regular expressions yet.
• Go back/forward – ALT + CMD + LeftArrow/RightArrow. Moves back between files that you opened. Useful for cycling through a call stack
• Go(Run) – CMD + Enter. I’m currently using this to quickly see results as a spike my way through learning about Objective C and the APIs
• Open Console – SHIFT + CMD + R. Useful when debugging using log statements and looking at what’s going on.

I’ve also found application-wide standard keyboard shortcuts really helpful as well

• Cycle through different applications (XCode, Interface Builder) – CMD + TAB
• Cycle through different windows in the same application – CMD + ` or CMD + ~. These are all really useful because Apple applications have a tendency to open many many windows, not really ideal for keyboard use.
• Open help – SHIFT + CMD + ?. This is really useful when no keyboard shortcut is mapped, or you want to access a menu and can’t remember what it was. Once you have the Help dialogue open, start typing the name of the menu item. I’ve used this quite a lot to access the Refactor menu item which pops open another window.

Of course there are many more keyboard shortcuts. These are simply the ones that I’ve found I’m getting the most productivity. I wouldn’t say all of development can driven through the keyboard alone, but it’s a pretty good start for now. What are your favourite ones?

I’m a huge believer in accepting multiple models as different ways of looking at the same set of data. It’s just simply different glasses to see different things through. One of the glasses I’ve been putting on more consciously is that of David Kolb and his model on experience learning. Read more about it here.

It follows a simple cycle: Experiencing -> Reflecting -> Generalising -> Applying -> (Back to Beginning)

Here’s how I go about applying it. I follow one of the wonderful tutorials from Apple on their iPhone development, focused on simply trying to step through the cycle and get some visible success (Experiencing). I then spend some time thinking about what new tidbit of information I’ve learned (Reflecting) and trying to come up with some way of fitting it my general mental model of how it works (Generalising). I then try it out on my prototype application to see if I truly understood it (Applying).

Having read about the model a while ago, I think there are a few key things to focus on when using this model:

• Keep it small – I could choose to run through all of the different Apple iPhone tutorials one after the other. This doesn’t give me any chance of reflecting, generalising or applying the material. Given my very forgetful nature, working with one tutorial at a time through this cycle is important. I try to keep this cycle in terms of a couple of hours, not a couple of days. Attempt to pick up knowledge incrementally.
• Rinse and repeat – Going through this cycle one doesn’t guarantee you’ll actually learn everything, or even anything. I’ve found I got to the end of doing something and didn’t have any general model. Iterating lets you mine and discover new lessons. I repeat the same exercise, and as I do, I notice I pick up different things.

Interesting it is these two aspects, incrementing and iterating that is at the heart of working in an agile manner. Notice how it’s all about learning then?

I’m a big fan of XP’s practice of spiking solutions. Although I’m not currently doing TDD because I barely know enough about iPhone development to make myself dangerous, I haven’t quite dropped all practices. I still use source control (just a local SVN repository) against the root of my spikes directory.

Here’s how I’ve been structuring myself:

The benefits of this let’s me quickly create new projects to learn a single lesson given the numerous tutorials out there, and then put that under source control for reference code at a later stage. I then spend some time integrating it into the MyPrototypeProject, making small incremental commits as I make progress. The best part is that if I make a mistake along the way, all I have to do is a svn revert -R . to get back to a working state if I get too frustrated or lost.

Late last week, Andy Yates got me onto the whole Hello World application for the iPhone. Since then, I’ve been dabbling around a bit more trying to get my head around it. After having studied how people learn things using models such as Shu Ha Ri, the Dreyfus Model of Skills Acquisition, and Kolb’s learning cycle, it’s fascinating to try to understand how best to pick it up.

Here are some observations that I’ve made so far:

• There are many different dimensions to learning how to write an iPhone application. First, there is the fact that it’s written in Objective C, so you’re learning about the syntax and intricacies of a new language. Secondly, you are learning new development tools including XCode and Interface Builder. Thirdly you are learning about the libraries, documentation, and understanding how things fit together.
• I intentionally recognise myself as being at Shu level (in Shu Ha Ri) or a Novice (on the Dreyfus Model). This means that I want to have some quick wins, get stuff working and worry about how it all fits together in the next stage. I’ve found that repeating the same exercise (almost like a kata) has helped me understand how things relate to each other just that little bit more.
• Writing a journal helps. I intend on blogging about some things that I’m discovering. It might help one person out but it will sure help me articulate clearly my understanding (or lack of understanding) about the topics that I’m finding. When I don’t blog, I’ve got a little text file with snippets on what things I’ve discovered and what things still puzzle me. It’s helping me organise the random things that I’ve got.
• Interestingly, I’m less interested in following some of the practices I would if writing a production application. This means I’m not worrying too much about refactoring or testing until I get the basics down. I don’t want to confuse the concerns of exploration and learning with verifying the system works (which I can barely get going right now). When I am more confident in my knowledge, I’ll definitely spend more time thinking about these things.

Definitely agree with this from the 10 Things I Wish Lean Practitioners Wouldn’t Say in 2010 (via the Lean Blog):

7. “If you can’t measure it, you can’t manage it.”

I don’t believe that statement. I think this phrase should be avoided and it certainly shouldn’t be attributed to Dr. W. Edwards Deming, as it often is mistakenly. Dr. Deming never said this and he, in fact, meant quite the opposite. Some of the most important factors in a system are very difficult, even impossible, to measure. That doesn’t mean you can’t try to manage them. John Hunter, friend and fellow blogger, has the definitive take definitive blog take on this here…

Don’t get me wrong. Metrics are important but they aren’t always most important.

Assuming that people make it to the Covent Garden venue tonight given all the snow conditions, then I’ll be running the Top Ten Secret Weapons for Agile Performance Testing presentation Alistair and I ran at Agile 2009 for the North London British Computer Society branch. Here’s the email detailing it all.