Blackout for SOPA and PIPA.
Click to learn more
Posterous theme by Cory Watilo

Filed under: agile

Cost of a meeting

This is probably a redundant observation and there's many more scientific calculations out there created by much smarter guys, but here's a formula I found usable.

When you're planning a meeting, take the following things into account:
The people you invited have to prepare themselves before the event (creating slides, taking notes, going through the ticketing system, etc), and repair themselves after the event (coffee, grouping up, bashing something, etc). Empirically I've found that an effect of a meeting could take an hour or two per person.
It goes without a saying, that the net price is the product of the length of the meeting in hours and the hourly rate of each attendant. But in addition, there's the distraction time (described above). Also the happening draws time from delivering values, so that factor should be taken into account as well. Here's my formula.

Cost

  • R is the matrix of the hourly rates of the participants, so sum(R) would be the total hourly cost of the people involved.
  • l is the length of the meeting in hours
  • p is the number of people attending, thus R has p elements
  • Alpha is the distraction time in hours. Normally 1 to 3
  • r is the number of remaining issues after the meeting
  • 1+(1/(r+1)) part of the formula makes the cost even higher, if the time spent on the meeting could have been spent on finishing all the remaining tasks.

 

The r needs some explanation.It stands for "the number of remaining issues after the meeting"

Of course the "remaining issues" and the "issue count" could be replaced by hours, complexity points, or whatever you like. For the demonstration, I'll use remaining issues.

Expanding the value, we get an equation as follows:

Costdeltai

  • ir is the number of remaining issues
  • vi is the average issues done in an hour by one person in the team
  • h is the working hours in the day
  • p is the number of people attending
  • P is the number of people in the team

Let's say you are on a 2 week (9 coding days) sprint with a total issue count of 50 with a team of 8 people where you have h as the working hours daily set to 6. That would make:

P = 8;
D = 9;
T = 50; (total issue count)
h = 6;

That would mean:
vi = T/D/h/P = 50/9/6/8 = 0.11574

So when you plan a 2 hour meeting for 4 people when you have let's say 30 issues left,
ir = 30;

And that would make r:

r = ir-(vi*l*P)+(vi*l*p) = 30-(0.11574*2*8)+(0.11574*2*4) = 29.074

You could verify this equation when you send all your people to the meeting, the r be equal to ir:

r = ir-(vi*l*P)+(vi*l*P) = 30-(0.11574*2*8)+(0.11574*2*8) = 30

If everyone on your team earns $50/hour, the cost of this 2 hour meeting with a distraction time of an ideal 1 hour would be,

Costexpanded

Cost = (400*(2*1))*(1+(1/(1+30))) = $825.81

 

ASAP Driven Development

Asap

Today, I want to talk about the term we made up in times when we believed that it described the way we work: ASAP Driven Development (ASAPDD). Sadly the term As Soon As Possible is abused. It should mean that "whenever you have free resources", but it's commonly misinterpreted as "now".

If I'd to place it in the context of Agile, I would derive it from Kanban with one slight modification: the task you're working on is only important until the next task's priority doesn't exceed the current one's. In extreme cases where business is completely aware of what the costs of switching tasks without finishing them are, it might work. But in cases which I've seen, the stakeholders didn't even know that this is happening. Even more, the task switch didn't mean that you don't have to finish the one you just put behind. That's still top priority, but the new one is even more important. It took me quite a lot of time to truly understand what is going on, I'll drive you through my observations.

Symptoms:

If I had to describe the symptoms in one word, I'd say: pain. What hurts in ASAPDD gone terribly wrong? As a developer, you never know how much time you have before you're forced to work on something else. If you don't know how much time you have, you have to finish as soon as possible - meaning the simplest and fastest possible way, while ignoring all professional needs - in order to flag something finished. If you can't finish before you receive a new task, then you'll have 2 tasks on you to finish ASAP, and so on, and so on. Of course you can say no to a new task, but that would leave you without a job. Given this situation if you know that you most likely have to put your style, cleanness and reputation aside to do your everyday job, it hurts and undermines your motivation ... if you care about such things of course.
But what about managers? I had the luck to be a manager in such environment too. You're told by your superior that the stakeholders do not care, and you can't communicate negative things towards them. You're told that whatever they want, is to be done. Given this, you have to promise that you'll get the task done, and you must tell the same to the developers resulting in a new 'top priority issue'. You'll say that this is even more urgent than the others. If not, the other tasks then must be completed by yesterday in order to get work done on the new one. What happens when the programmers raise their flags about a task and you tend to agree with them? You'll end up as a messenger between sides, but you can't be truly honest with the product side, and you'll have to convince the team to be passive-aggressive and do as they are told. You can try to defend your team against insane requirements, but say hello to bonuses and appreciation. You'll be the guy who always says no and argues, while there's the other ones who understand the tasks and get them done. This is a true enemy to creativity and innovation. As you might guessed, the side-effect of such "pain" is fluctuation. People get under-motivated, fed up, exhausted, laid off or they just simply quit.

Cause:

I tired really hard to understand what's going on, so that I could do things to fix it in my own circle of influence. Clearly there was a crack in the flow of communication. But why? Whenever top management or the product team came up with something, they were hardly told that it can't be done, or can't be done in a week, or simply that they should come up with smaller chunks of functionality. They believed that when they feed the development team any input, they get the output they wanted in a short period of time without any further interactions. Nobody said truly no to them in order to properly schedule or break apart a task. Nobody communicated the need to finalize, stabilize previous features. If they were demoable, they were done. Even if someone did say no, then the top management came and pushed the feature into development regardless the raised flags. Inspecting the pain from the bottom, I saw that even if we told our managers that we can't do something or that we think it wouldn't be any good to the product at all, they pushed it on us without defending our professional opinion. Even if our managers did try to defend us, their superiors denied help. Even if the superiors tried to help, the CTO wanted to impress the CEO so much, that he didn't help. Even if the CTO was convinced, the CEO was the one who seemed to have no common sense. Finally if even he thought that we're in trouble, the solution was to "hire more resources", 'cause the feature is so important, that it must be done. So as the previous ones. I couldn't blame the CEO though, he was hardly ever aware of the fact that we're having hard times completing tasks. Why should he even think that hiring more people isn't the cure? He thought, that everything is going smoothly and that our throughput is influenced by the number of people working. I'd say he wasn't respected enough, and he was constantly lied to.
Anyways, how could a feature be so important that it needs instant development? Well, the sales made an insane promise and the money's already spent on shiny new golf clubs? Or did a newsflash somehow got public weeks before planned describing nice new features which didn't even get into development? Or simply nobody knew that we were not remotely ready with our current work. Whatever the reason is, the managers and the developers had to fix someone else's mistake. Mostly.

Cure:

Why mostly? Because we as developers should have stood up for ourselves and defend our own beliefs, profession and credibility. We were too afraid that we could lose our jobs. So what could have been done? Honesty, respect, professionalism and metrics. Clearly it's much easier said than done, but let's see what we could have done from both sides.
We should have increased transparency by radiating the metrics of our codebase. Telling everyone from top to bottom, that our codebase is rotting, and if we won't have time to properly code a feature, the time we'll spend on each following task will exponentially increase. We could have told our superiors, that if they want to keep a sustainable development, we should start caring about the health of our product. If we could get our product and top management team to hear us out and try to accept that we must re-calibrate our workflow, we might end up in an adaptive system such as Kanban, so that they could re-prioritize the upcoming tasks until the very last minute. If instead of staying quiet we would respect our co-workers by telling the truth and giving honest feedback, we would give our managers / leaders the ability to think of a solution instead of leaving them in a belief that everything is fine. I'm sure that they would try to make their own company work at any cost... if they knew what to fix. Maybe we could have even helped them by providing various solutions they could choose from? Ranting never helps without providing a possible solution to the problem.
What's to be done with the sales / marketing guru who constantly screws up and ignites new ASAP developments? Help him out! Find out why he's doing such stupid things. Does he even know he's not doing well? Does he get any feedback, or just the premium after each deal? I even know that the product team sometimes needs to test an idea and see if it's viable or not. They can use the main development team to rapidly build things, but instead of burning tons of $ on coding man-hour, try to do a paper mockup and invite a control group. It's less expensive, and gets you much closer to your customers. What happens when a rapidly developed idea doesn't work out? The programmers have to revert weeks/months of work. No matter what methodology you follow, that always introduces motivation loss.
To wrap it all up, I don't say you need to change organizational structure to avoid ASAPDD. Just be honest and make sure people would want to be honest with you. Accept feedback even if it's negative, and think of it as a candidate to making things better. You won't get a negative feedback unless the one who provides it doesn't believe that you can do something about it.

 

Literature and help

 

What should have you learned from Steve Jobs?

Applenosteve

I'm no Apple fan. I've tried several Apple products, but I wasn't satisfied at all. I'm just not their target everyday tech noob. I like to fiddle around with every little aspect of my systems. No hard feelings, we're not a good match, that's all.

Despite my incompatibility with the Apple philosophy, I truly admire Steve Jobs' absolute professional way of thinking. He gave the world some super-simple user interfaces by realizing that software is built for users. Users, who are most unlikely nerds. His stubborn and sometimes indecent attitude drove out those features which seam so obvious ever since, that it feels like you always had it.

So what I learned from him and think that every person involved in software craftsmanship should learn also? You produce for users. The one and only important thing to keep in mind while creating a feature is that it must be communicating it's intent and the value for your user. Nobody will want to use stuff they don't need. Nobody will use something if it's more complicated than what they can use. On the other hand, if your users feel that they are overlooked, you'll earn a bad reputation.

I feel that Apple products are less configurable than I'd like them to be, and they want me to use them the way they think I need to use them. I hate that, but for that genius targeting, I don't feel that Apple could be blamed. We're no match, I'm not their user. They produced for their users, that's all.

If we combine this theory with Agile thoughts, you can easily come to the core genius of Jobs:

  1. Grab yourself a feature from the perspective of a User, which has business value for you
  2. Identify the value and intent of that feature and marketing it well to both business and users so they truly understand it
  3. Make sure it can be reached and used the most convenient way for the target user
  4. Ensure that the functionality serves the intent
  5. Don't build anything more than that
  6. Never ever break any of the rules above

Rings bells?

The way I see it, Steve Jobs did nothing else, than kept these rules without exception, and was a demanding user of his own products. He produced for those, who use Apple products and on the way he made us question the presence of overcomplicated interfaces.

I'm hating that my social sites are spammed with "RIP Steve" messages, but I found one which made me write this article:

If you want to honor Steve, don't mourn. Do your best work every day. Live your life to the fullest. Never settle. His spirit lives on.
via Sebastiaan de With

Just read: Lisa Crispin and Janet Gregory - Agile Testing

Media_https3amazonaws_tftsb

Product Details

  • Paperback: 576 pages
  • Publisher: Addison-Wesley Professional; 1 edition (January 9, 2009)
  • Language: English
  • ISBN-10: 0321534468
  • ISBN-13: 978-0321534460
  • Product Dimensions: 9.1 x 6.9 x 1.4 inches
  • Shipping Weight: 1.8 pounds

For developers / testers not new to the agile world this book can be the most depressive piece of art. It tells a story of a way of development you know is out there, but most not yet have reached.  Lisa Crispin and Janet Gregory share their experiences through personal stories and examples from others.

There are some questions the authors want to answer:
  • As a tester, what is my role on an agile team?
  • How do I transition from a traditional phased/gated development cycle to agile?
  • How do we get testers engaged with the rest of the agile development team?
  • What tools do I need?
  • Who does what testing on an agile team?
  • How can testing "keep up" with short iterations?
  • How do we know if we're doing a good job of testing? How can we improve?
  • What do testers do the first few days of an iteration, before any stories are done?
  • None of our testing is automated. Where do we start, and how do we find time to do automation?

Did I get answers to all this? Yes I did! There's a way of thinking that I was never aware of as a developer. I can now look through the eyes of a tester and my design is driven by the phrase: "Ok, but how would I test this?" How would I present that I have done what I was told to? How can I be sure to create what the customer wants me to. Besides giving a throughout view upon the work of an agile tester we get to know the fundamental elements of SCRUM.

Editorial Reviews

Review

Just read: Mike Cohn - User Stories Applied

Media_https3amazonaws_ebimo

Product Details

  • Paperback: 304 pages
  • Publisher: Addison-Wesley Professional (March 11, 2004)
  • Language: English
  • ISBN-10: 0321205685
  • ISBN-13: 978-0321205681
  • Product Dimensions: 9.1 x 7 x 0.7 inches
  • Shipping Weight: 1.2 pounds
I was holding this book in my hands a few times before I actually started reading it. I didn't believe that a book can actually get me into a mood that extreme development and agile means to me, but I was wrong. This book should be read by everyone who is envolved in software development. I believe that this approach could be aplied to other aspects of life, but that's just my opinion. We will be referring to this book in the Munchkin project, it gave us a lot of great ideas!

Editorial Reviews

Product Description

The concept of user stories has its roots as one of the main tenets of Extreme Programming. In simple terms, user stories represent an effective means of gathering requirements from the customer (roughly akin to use cases). This book describes user stories and demonstrates how they can be used to properly plan, manage, and test software development projects. The book highlights both successful and unsuccessful implementations of the concept, and provides sets of questions and exercises that drive home its main points. After absorbing the lessons in this book, readers will be able to introduce user stories in their organizations as an effective means of determining precisely what is required of a software application.

From the Back Cover

Agile requirements: discovering what your users really want. With this book, you will learn to:
  • Flexible, quick and practical requirements that work
  • Save time and develop better software that meets users' needs
  • Gathering user stories -- even when you can't talk to users
  • How user stories work, and how they differ from use cases, scenarios, and traditional requirements
  • Leveraging user stories as part of planning, scheduling, estimating, and testing
  • Ideal for Extreme Programming, Scrum, or any other agile methodology
---------------------------------------------------------------------------------------------------------- Thoroughly reviewed and eagerly anticipated by the agile community, User Stories Applied offers a requirements process that saves time, eliminates rework, and leads directly to better software. The best way to build software that meets users' needs is to begin with "user stories": simple, clear, brief descriptions of functionality that will be valuable to real users. In User Stories Applied, Mike Cohn provides you with a front-to-back blueprint for writing these user stories and weaving them into your development lifecycle. You'll learn what makes a great user story, and what makes a bad one. You'll discover practical ways to gather user stories, even when you can't speak with your users. Then, once you've compiled your user stories, Cohn shows how to organize them, prioritize them, and use them for planning, management, and testing.
  • User role modeling: understanding what users have in common, and where they differ
  • Gathering stories: user interviewing, questionnaires, observation, and workshops
  • Working with managers, trainers, salespeople and other "proxies"
  • Writing user stories for acceptance testing
  • Using stories to prioritize, set schedules, and estimate release costs
  • Includes end-of-chapter practice questions and exercises
User Stories Applied will be invaluable to every software developer, tester, analyst, and manager working with any agile method: XP, Scrum... or even your own home-grown approach.