Lean Agile Scotland 2013

August 11, 2013


I’m speaking at the Lean Agile Scotland conference on the 19th/20th of September 🙂 The subject is SOLID TDD and the abstract is below.

SOLID TDD

Software developers generally don’t write poor, unmaintainable code out of any malicious or deliberate intent. They do it because software development is complex and there is not enough feedback in the process to ensure they adhere to good SOLID OO principles. By using TDD, and listening to the feedback from the tests, you can be guided to adhere to the SOLID principles…resulting in improved TCO and significant quality improvements.

Lean Agile Scotland

It’s a really good conference with a wide variety of speakers. I enjoyed attending so much last that I proposed a talk this year and wrote a two part review of the sessions I attended in 2012 (part 1, part 2). It’s being held at Our Dynamic Earth in Edinburgh and you can check out the list of speakers here. I’ll hopefully see you there…and if you post a comment I’ll see if I can get you a discount code 😉

Advertisements

Martin Fowler states that the first law of distributed objects is: don’t distribute your object. I think that the same applies to distributed teams. Co-location just makes things easier and distributing people makes it all much, much harder. However, sometimes, for reasons outwith our control, you end up with a distributed team.

I’m hoping to catalog some techniques I’ve used to run distributed retrospectives (and possibly other activities like stand-ups, planning, pair programming, etc) in a series of posts under “Distributed Team”. It’s not an in-depth study of the retro techniques, rather notes and observations on how well they worked with a distributed team (and what changes can be made to help).

Why? Well I’ve been working on distributed Agile teams almost exclusively for the last 5 years and have tried many things to make the team feel more inclusive, work better together, and ultimately be more effective at delivering software. Some of these things worked well and I’d like to share them.

Sailboat

I like the Sailboat retro technique as it’s very good at gathering data and quickly grouping it. It is also fairly simple to understand, requires minimal preparation, and overall is a great introductory technique for teams unfamiliar with regular retrospectives.

For those of you unfamiliar with this retro technique, there is a picture of a Sailboat. It’s essentially a visual collaboration game where you place issues around it to signify:

  • Sails – what is making the project faster/better ?
  • Anchors – what is slowing down/dragging on the project ?
  • Rocks ahead – what risks/dangers are coming up?

Distributed Sailboat

I flexed my Paint skills to the max and sketched out the boat below, feel free to use it yourselves.sailboat

First off, we all dial into a conference line. We’re in a Windows 7 environment, so I ran a screen-sharing session with the Sailboat as my background (and a nice clean desktop). Using the Sticky Notes application, I would capture each idea as it was raised on a new note, then locate it appropriately over the image on my desktop.

It sounds simple, and for this technique, it worked really well. Once you’ve aligned the Sticky Notes around the boat, colouring them also helps. This is how ours ended up:

sailboat_obfuscated

Summary of tools

  • Conference line
  • Screenshare
  • Paint (or use my image above)
  • Sticky Notes

Like many distributed retro techniques, this relies on one person driving the shared screen. With a lightweight activity like this, where the other participants are providing most of the data and discussing the groupings, it’s not too much of a burden.


A few years ago I was lucky enough to attend Tom & Mary Poppendieck’s Lean Software Engineering course when they visited Glasgow. One of my colleagues recently reminded me of the assertion Mary made on that course that Test Driven Development is a minimum bar for a professional software developer to reach. With that in mind, I came up with the message below that I hope will inspire & motivate or at least catch the attention of people just starting out in this line of work (and perhaps some of those who’ve been around a while too).

What is a professional software engineer?

Wikipedia defines a professional as:

I don’t like that definition, it’s far too narrow. It defines a professional in terms of group membership and ability to generate income. If I want to have someone on my team, hire someone, those are not the top attributes I am looking for. When I build a team, I want to want people who care about quality and focus on maintaining high standards consistently…not just when it’s easy to do so.

Perhaps we should stop using the word “professional” to describe quality-focused software engineers and go for something more like “software artisans” or “craftsmanship” to indicate the qualitative attributes we seek?

What is the difference between a professional and an amateur?

I think we confuse professionals and amateurs (gifted or otherwise). I can use a hammer and saw, I could probably build a fairly basic shelter given enough time…I wouldn’t want to live in it because it would be a death trap, but it would probably be ok in the very short term to keep safe from the elements. If I wanted to build a permanent home, I’d get professional builders & architects in to do the job properly.

So how can we separate amateurs from professionals?

I think it can be summed up by the aspirations of the individual:

  • An amateur aspires to achieve perfection
  • A professional aspires to deliver very high quality results, consistently

An example

I know several very keen amateur photographers. They have all the latest cameras and lenses, they know all about shutter speeds, focus, exposures, lighting, etc. Most of them have taken some absolutely spectacular pictures. However, those pictures generally represent a huge investment in time, and more discarded pictures than they’ll ever admit to. Professional photographers generally can get a very high quality picture in a fraction of the time and their pictures are generally of a far more consistent quality. This is because they have mechanisms and practices in place to govern the quality of their output. Sure, there might not be as much free expression in their work as in an amateur, but that is most likely the nature of the pictures they are being asked to capture, rather than taking pictures of whatever you like, whenever you feel like it. I think that the same is true in software development.

Low Barrier of Entry

The barrier of entry to software development is very low. This means there is a broad spectrum of quality across the industry. I recall being about 7 years old and getting the computers in Tandy to display my name, infinitely scrolling across the screen. I can write a program, does that make me a professional software engineer?

When I was a student, I wrote some MS Access and VBA front-end to manage stock and re-ordering from suppliers. I earned money from that, which I lived off of. Does that make me a professional software engineer?

A long time ago I passed my Java Programmer Certification, my degree also qualified me for some kind of partial membership to the British Computing Society (can you tell that I’m not overexcited by that?). I’m a member of two professional groups, does that make me a professional software engineer?

We need a culture of quality, we need to be software artisans.

Becoming a software artisan is not about ticking a few boxes, reading a book, getting your code to compile, then declaring it to the world how wonderful you are. It’s a journey that starts with a sometimes difficult realisation:

  • You are not the world’s most clever software developer
  • You are probably not even in the top few percentile

That’s OK, you are in the majority. That doesn’t mean you can’t be a good software developer, it just means that you need to work at it and adjust your attitude for learning. Understand that you are not perfect, and introduce good practices and checks to ensure that you are producing a quality product…rather than just banging away on the keyboard until it “seems to work”.

Test Driven Development is exactly the sort of process that can raise the quality of your code dramatically, at the same time as reducing the chance that it won’t work. People make mistakes, quite often silly mistakes, sometimes more complex and subtle ones. If you’ve crafted your test before you start coding, then you’ve got a clear, black & white (green & red?) indication of whether you have made a mistake or not. It provides you with confidence to try out different design patterns and refactoring. TDD is a software developers safety net.

Following the SOLID ideas around writing good OO code, that’s something else that can raise the quality of your work. It will make it more robust, easier to use, more readable/less confusing, more amenable to refactoring, and various other positive things. However, you have to remember to follow those ideas with all the code you write. TDD guides you in the direction of the SOLID ideas because the further away from them the code is, the harder it is to test. A difficult test is an indication, a code smell, that the code under test might be able to be refactored/redesigned to be more easily testable…and that very often involves making it more SOLID.

TDD, it’s not just a good practice, but it enforces other good practices too!

Learning TDD

I’ll not sugar coat this, TDD is hard to learn without lots of practice. However, the same can be said of any worthwhile skill. I like to think of it like riding a bike. We can all agree that travel by bike is faster than walking…but not the first time you ride a bike. No, you get grazed knees and bruised elbows as you fall off, but gradually you stay on for longer and longer and it eventually becomes second nature and you start to achieve your potential.

There is a great ring of truth to the rule on 10,000 hours of practice leading to mastery of a subject rather than some innate talent. There are some practices you can do to cut down on that time that I’ll steal from a rather good infographic.

  1. Get a coach
  2. Surround yourself with like-minded individuals
  3. Build expert habits
  4. Don’t waste time on the small stuff
  5. Deliberately practice (not just mindless repetition)
  6. Teach others
  7. Find someone to kick your butt if you fall off track

I reckon I’ve clocked up at least my 10,000 hours of TDD, and I’m STILL learning new and better ways to do it.

The Essence of Agile

January 21, 2013


I love to talk about Agile software development, Lean principles, and am currently trying to get a better grip on Rightshifting. However, when people ask me for advice it can be hard to recall details and specifics, especially if it’s either an area you haven’t thought about for a while, or something that you maybe only have limited perspectives or experience of. When this happens, it’s invaluable to be able to reach for some guiding principles.

The Agile Manifesto is a wonderful resource for this and I hear it’s even being refined (continuous improvement is a wonderful thing). Generally, when asked about them, I’ll end up mis-quoting them…even though I understand what they are about, why they were written down, how they are generally interpreted, etc. Who would have though that those 4 statements would be so difficult to remember? So I wanted to capture an even simpler interpretation of them. I was also keen to include as much from Lean as possible too. It struck me that the strongest, most often recurring theme is “feedback”…and the more I look at it, the more I’m convinced that Feedback is the very essence of Agile. I should probably back that up with evidence of some kind, or at the very least, my opinions and observations.

Feedback

If we examine the Agile Manifesto, we can see that it is all about favoring rich, prompt feedback over other options.

  • Individuals and interactions over processes and tools

This is all about interacting with people, and in general, people are pretty good at giving prompt, quality feedback. Sure, we could all be a little better at it, but you generally get much more feedback talking to someone than using a tool or following a process to accomplish the same goal. For example, handing over a piece of work in a team distributed by time-zone. You could follow the process and update the story with the latest information, and you could use a tool, JIRA perhaps, to capture that information and make it available remotely to the rest of the team. However, having a conversation and brief guided tour of the feature in it’s current state imparts information much more effectively, and provides opportunity for questions and clarification.

  • Working software over comprehensive documentation

The documentation for a project is rarely a good guide to whether the software works or not…even when it gets completed. The problem is that documentation generally lags behind the software product and is often quite far down the priority list when identifying new work. Ultimately it provides poor quality feedback, due to it generally being out of date, and it doesn’t provide it in a useful time frame.

On the other hand, working software is a very rich feedback environment with every click and gesture providing more feedback instantaneously. Continuous integration, yet another feedback mechanism, should allow you to get access to such rich feedback each day (or even more frequently).

  • Customer collaboration over contract negotiation

Our customers write stories in the form of “As a…, I want to…, So that…”, and that’s a good thing. However, it’s just a starting point for a much more detailed conversation about the details. It provides opportunity for change too. Instead of asking for every feature they can think of up-front, they are involved in the evolving product, which should allow them to select and prioritise work in an intelligent manor.

Contract negotiation is a much slower process and much more guarded in the language used. I always see it as both sides trying to make sure they are not going to be punished for failure rather than a collaborative process to deliver something. So it’s not particularly prompt, and the language used tends to disguise the true meaning…so not very high quality either.

  • Responding to change over following a plan

Prompt feedback in essential as the longer you go without feedback, the more opportunity you have to go down the wrong path…or inversely, the more often you get feedback the more opportunity you have to perform a course correction based on the latest information at hand.

Following a plan when you know it to be inaccurate or incorrect (or even a complete fantasy) leads to a culture of no longer questioning, just doing.The act of planning is invaluable, it forces you to consider options and think about how things will work out. However, the plan itself diminishes in value rather quickly as the assumptions and estimates it was built around meet up with reality. Sometimes it’s value drops to zero (or in fact below zero and becomes a burden) even before you start following it.

Test Driven Development

High quality, prompt feedback turns out to be the key concept to all sorts of other Agile software development practices. My favorite example would of course be Test Driven Development (TDD). This provides feedback on a number of levels:

  • Seeing the test results go from failing (red bar of shame) to passing (green bar of joy) is the most obvious form of feedback provided by TDD and should start a round of refactoring now you are in a “good” state.
  • By writing the test first, you get feedback on your understanding of the task. It is very difficult to devise a test when you are unclear on the desired behavior.
  • By writing the test first, you get feedback on the state of the existing code-base. If the test is difficult to write, that feedback is telling you that you should first look at refactoring/redesigning the surrounding code.
  • By running all the tests frequently, you are getting feedback on the state of the entire project and how your current piece of work is integrating with it.

The huge advantage of TDD is that you get this feedback really quickly, it’s incredibly targeted  and it’s very specific. That is an almost perfect definition high quality, prompt feedback.

Pair Programming

I’ve heard code reviews talked about as a poor man’s substitute for pair programming. While I agree with the sentiment and acknowledge that both provide feedback on code, I think the gap between them in practice is much, much bigger than most people realise.

The obvious difference is that code reviews happen after the code has been written…sometimes quite a long time after the code has been written. So code reviews do not provide prompt feedback. This is bad…actually, I’m not sure that “bad” the right word. Maybe I should use “disappointing“? Yes, this is disappointing because the effort is being spent to review the code but the opportunity for getting appropriate returns on that investment have passed by already. In my experience, code reviews generally provide a lower quality of feedback than pair programming too. This is partly because they are conducted some time after the code was written, but also because it’s much harder to really understand a piece of code when you were not there at it’s creation.

So there you go, it’s all about the feedback. Make it high-quality, and seek/provide it promptly. I’ll grant you, it’s not exactly an epiphany, but it was an observation I thought I should share. Feel free to share or suggest your own observations on feedback in the comments section…or even to disagree with me.