Lego Lean Game in Sardinia

Last month me and Danilo presented an extended version of the Lego Lean Game at XP2009 in Sardinia, Italy.

This was the first time we tried this version, and it can be considered a success, with good feedback and some people asking information to run the workshop within their companies/classes.

You can find more information about how it went on this post Danilo wrote, and the slides are also available here (if you like to see how it went, pics are here). As he said, we prepared a package with all the material needed to run the workshop, so feel free to ask us for it if you have participated and are interested in doing it : )

Dev Complete? No!

Recently we’ve had a discussion in a project I was working on about the concepts behind dev complete and qa complete stories, which are normally in a lot of agile wall’s swim lanes, and how they affect the project’s flow.

The point here is not to discuss how to measure your goals, since this was discussed in previous posts, but what I wanted to explain is how (what I’ve realized during that discussion) I don’t like the term dev complete, and why it can affect your team.

First of all, development complete implies the idea that we don’t need any more development in one specific story, and as anyone who has been in an agile project might have noticed, this is less true than we wanted it to be.

What frequently happens is that stories which are in the dev complete lane come back to development when they don’t meet the QA criteria, and suddenly development has to be done again for something that didn’t need any more development.

And what I find most annoying is that development complete has the word complete on it, which has an underlying meaning that someone (the devs, in this case) have completed their job, and that they could feel good about it at this point.

What goes away when this assumption enters someone’s mind is the fact that the objective (for all the team, including those devs), is after the qa complete stage, when the story is actually delivered. And this situation just gives another motive to the always disturbing separation between developers and qa’s.

So if you believe in how measures affect the results of a team as I do (more info on that here, here, here, here, here, here and here), change all your dev complete stories to qa ready, or something similar, and enjoy a little bit more peace of mind.

What is Your Goal?

One of the best things about Agile is the introduction of software development as a system. Software stopped being treated as a sequence of separated steps to be seen as people with different competences working together to achieve one goal: deliver software.

This is not new in any sense, and it was exemplified by Deming on one of his books:

I could do a much better job (fewer mistakes) if I knew what the program is to be used for. The specifications don’t tell me what I need to know.

Despite this advance, most software development teams fail in really understanding this concept, and still normally don’t see the power of using one unique measure to manage the project, not getting the idea that the effort of the system should be only measured once, in what is its goal.

You must be asking what is the problem of having different measures to verify the sanity of the project. And that is what Peter Drucker explains in his Post-Capitalist Society book:

In knowledge work… the task is not given, it has to be determined. ‘What are the expected results from this work?’ is the key question in making knowledge workers productive. And it is a question that demands risky decisions. There is usually no right answer; there are choices instead. And results have to be clearly specified, if productivity is to be achieved.

What it means is that tasks cannot be fully specified anymore, the workers have to make decisions every time about how to proceed in certain situations, and they can just do it correctly if they have a clear vision of what is to be obtained, and what is the final goal of the work they are doing.

This concept is also illustrated in the draft version of Mary and Tom Poppendieck’s latest book (still in the draft version), when they are explaining the case of Southwest Airlines, which has as main advantage against the competition, the fact that its planes stay less time in the ground, thus generating more revenue.

Southwest maintains a systems perspective; it doesn’t let individual department measurements or increased revenue opportunities distract it from the primary objective of maintaining profitability. Southwest makes it clear to every employee – from the agent closing the gate to the baggage handler transferring luggage – what is important from an overall perspective. Everyone at Southwest knows the mantra: “Airplanes don’t make money sitting on the ground.” So everyone works together to get each plane in the air as fast as possible.

The important here is that we have one measure. One variable that everyone can rely on to make decisions during their work, and the ability to do it makes a whole difference in the overall performance of a team,  fact that often not considered in software development, where different measures distract people from the main goal.

As an example, a common situation I’ve seen in project is to track bugs within the iteration, and use it as a measure of code quality. Well, the goal of a software team is to deliver software without bugs, but it doesn’t matter at all if in the process of creating software bugs are found and solved prior to the software being released. If that is the way the team works best, so be it.

Another example is a case where a project had a problem with bugs creeping (this time, after iteration was finished and software delivered), and when discussing the fact we’ve realized that because of the pressure to deliver, we were delivering development complete, and not QA complete stories, so QA was actually done after the iteration finished, and yes, the team’s velocity was based on development complete points.

Well… if the goal you set to the team is to deliver dev complete stories, guess what you’re receiving in the end… dev complete stories!, it doesn’t matter how many times you repeat “Let’s focus on delivering quality software“. As Goldratt said, “Tell me how you measure me and I will tell you how I will behave.”

So, what is your goal?

Lean Lego Game @XP 2009

Next month, Me and Danilo Sato will be presenting the Lego Lean Game ate XP 2009, which will be held in Sardinia.

So, what is it?

The Lego Lean Game is an activity developed to teach people about the basic concepts of Lean thinking in a dynamic and fun way, demonstrating Lean practices in an imaginary production line to build Lego houses.

Why?

The idea came from the fact that Lean is becoming a common term in software development, but many people haven’t been introduced to the concepts that made it successful. This workshop aims at introducing this concepts to the participants, making them understand where Lean comes from, and why apply them in the software world.

Should I Come?

If you are interested in Lean, but haven’t had time to study about it, this is the perfect place for you. More experienced people are also welcome, since the hands-on activity makes you discover many aspects that might have been missed before.

If you want to have a better idea of how it is, you can check this video (sorry for the shaky camera : ) ), from the presentation we made at Agiles 2008.

Hope to see you there!

Porto Alegre Agile Weekend 2009

For the Brazilian crowd (or anyone who wants to be part of it), between the 25th and 26th of April will take place in Porto Alegre (my home town : ) ), the 2009 Agile Weekend, which has my friend Daniel Wildt as part of the organizing team.

This will be hopefully the first of many Agile conferences happening in South Brazil, and will serve to boost even more Agile adoption in the region.

Needless to say, I really wanted to go, but London is not close enough to Brazil yet…

More!

Since the advent of the industrial age, we have had a terrific word: “more.” It really worked for everything. When our roads became crowded, we built more roads. When our cities became unsafe, we hired more police officers, ordered more police cars, and built more prisons.

This is the introduction for one of the chapters of the book I’m currently reading, Information Anxiety, which talks about how to live in a world where we don’t have time to retain all the data that is thrown at us.

What I’ve found interesting about this sentence is how it can be applied in different areas, from police officers, like stated above, to software development.

It is surprising to see how many people that work in the area believe that a software project running behind schedule can be solved with a simple measure: throw more people in the team.

It is so appealing that nobody thinks it can go wrong, and they often forget to consider some minor points, like:

• time it takes for newcomers to understand the project and its domain
• time it takes for newcomers to know the people in the project
• the decrease of communication levels brought by the addition of new nodes

and more than often, the same persons that believe in this measure forget to take a look at their team in order to really try to understand the root causes of what is happening, in a totally anti-genchi-genbutsu way of solving problems.

In a recent project I’ve participated, 4 persons were added to a 3 pairs team in order to try to increase velocity the team was delivering. Needless to say that in the first week we had a 5-pair team with 4 newcomers, and if you looked at the team room, you could see that in each pair there was one person trying to explain to the other how the system worked.

It is pretty straightforward to understand that the team was in reality less than half strong, and that in the first iteration we delivered…. guess what? Half the points.

So if you are thinking about ramping up, think again, and again, and again, and spend some time just looking at how your team works before you make any decision.

Ignorance is Bliss

Throughout our lives, we study and practice the skill we find useful for an incredible amount of time, expecting to be ready when the moment comes that we have to use them.

Despite still agreeing with the practice/study paradigm, I’m starting to notice that knowing everything is not the best solution in all the situations. This thought came to my mind again when reading a recent article in the Sport magazine, about which conditions made possible to the British cycling team to win so many medals in the last Olympic Games (if you want to know more about it, you can read it here).

What caught my attention was the description of the research and development group, responsible to discover the best technologies to be used in the cycling competition. The group actually collaborates with many people outside the cycling industry, like F1 teams, and aerospace and defense companies. When asked to explain why, the head of development answered:

We really value ignorance. So we got to ask people who really know nothing about cycling. An aerodynamicist will ask: ‘Why do you do it like that?’ We’ll look at each other and say: ‘I don’t know.’ That really opens things up

This is also described by Richard S. Wurman, in his book Information Anxiety, where he describes common problems in understanding, citing the expert opinion syndrome:

We tend to believe that the more expert opinions we get, the more informed we will be. But we tend to forget that expert opinion is by no means synonymous with objective opinion. Unfortunately, most experts come with a bias that makes obtaining truly objective information almost impossible.

And when it comes to software development, this situation can be easily seen in coaching, either externally or internally. It is not rare to see coaching being done with a biased opinion, where coaches arrive with a ready-made solution that they want to apply, despite the conditions being face by the team.

Solving problems, complicated or not, has to be done with a clear mind. We have to assume our ignorance when facing any new situation, so we can understand it better and provide the best solution.

Distributed Source Control and Set-Based Design

That distributed version control systems are the current flavour of the moment, everybody already knows, so I’m not here to talk about the N reasons why you should not use svn/cvs anymore.

But what I hadn’t notice until recently is that git (or any other DVCS) actually allow you to do one very important thing in software development: set-based design

As Mary Poppendieck pointed out:

Toyota and 3M use the same concept for product design.  They explore the entire solution space and find intersections that everyone finds acceptable, gradually adding detail and converging on a solution.  This approach is called set-based design, and contrasts sharply with point-based designs which start with a single solution that undergoes a series of optimizations.  In most cases, set-based design produces the best design in the shortest amount of time with the least amount of communication.  It’s strange that this principle, so obvious when you are scheduling meetings, seems counterintuitive in the development environment

The eureka moment came to me in my latest project (in which i’m using svn), when I was thinking about exploring an alternative path to some code that was already implemented, but I thought it could be redone in a better way. How to do it with svn?

I could enter the obscure world of svn branches and merges, where I would have to fight hard to get my code back in one piece, but that didn’t sound inviting at all, and that’s why I haven’t actually implemented the second option, waiting to be more certain about it.

The interesting thing is that since I’ve been using git for the last year, I always took it for granted, and didn’t actually realize this benefit from DVC systems.

So, if you are thinking about why change from cvs/svn to a distributed system, add this point to your list.

Does it Really Work?

Last week during TW London Last Thursday event, I had the pleasure to see this presentation from Dave Robertson and John Johnston (or at least part of it), about how Agile and User Centered design are more a match, sharing goals and values, than different approaches to software development.

If you have some time you should really watch it, it is worth the time.

The overall presentation is really good, but the reason I’m posting here is one specific point that was mentioned, which I believe really hit the spot, and that’s when they say we should rethink the word work in the “the simplest thing that could possibly work” sentence.

This point goes back to the Agile Vs Usability discussion and it is very correct IMO, because it reiterates that development teams should not deliver any code just because it was quick to develop it and the client is happy (although he shouldn’t be at all) since it didn’t cost a fortune.

And what is interesting about this subject is how agile teams don’t usually accept low quality code standards (code without tests, lots of hacks, etc..), but easily accept low usability standards, not understanding that is also their responsibility to define what a good user experience is.

What I’m NOT trying to say is that the user should be left outside from the application design. He should definitely have his opinion (and a strong one), but should also receive advice in UX standards as much as he should in code quality, making sure that he understands what he loses when is trying to save money on each particular feature.

T-Shaped People vs Generalists

I’ve been reading Mary and Tom Poppendieck’s new book on Lean Software Development, and in one of the already released chapters, it mentioned the term T-Shaped people, which I had never heard in this context, and suddenly clarified a concept I have in my head for some time.

Since Scott Ambler published the essay Generalizing Specialists, it has become a trend in software development to talk about how generalists are better than specialists for a team, which (in a misinterpretation of what Scott meant) has leaded to a common anti-pattern, where persons become generalists in a lot of stuff, without having a deeper knowledge in any any area.

This way they know a little about a lot of languages, tools  and methodologies, but when it comes to make a difference, these persons are no assets to any team, since they don’t have any deep knowledge on any subject.

This was already covered by Jay Fields in this post, and what I want to point here is how the T-shaped term makes so much difference.
According to IDEO’s Tim Brown, in the  the article is called “Strategy By Design”, here is how a T-shaped person could be described:

“We look for people who are so inquisitive about the world that they’re willing to try to do what you do. We call them “T-shaped people.” They have a principal skill that describes the vertical leg of the T — they’re mechanical engineers or industrial designers. But they are so empathetic that they can branch out into other skills, such as anthropology, and do them as well. They are able to explore insights from many different perspectives and recognize patterns of behavior that point to a universal human need. That’s what you’re after at this point — patterns that yield ideas.”

And that’s what happens in software development. Once you have a deep knowledge in some language, for example, it is easy to branch out to different ones, since you can recognize the same (technical and behavioral) patterns, which will lead you to soon become competent in that area too.

But this situation does not happen if you always stay at the novice level, without never mastering anything you do.