How some piece of software started a very bad habit

I’ve never been a person who’d been late for meetings. I think I was late once to school and is the kind of person who really makes sure that I’m on time. We’re always first arrivals at parties.

But when I started working for my current employer, I started missing meetings and becoming late at occasions. I even have double booked meetings in my calendar. After having worked for nearly 15 years, one cannot help wondering what started this bad habit.

And it boils down to software which does not help me in the most fundamental way. When I’m invited to a meeting it is crucial to know if I’m already booked. I guess that this is just not me; most people have a problem being at two places at the same time. So, a calendar for professional use should probably warn me directly if I’m invited to a meeting when I’m already booked in my calendar.

Also, if I make a booking, it’s good to know if the participants are available or not during the time in question. And again, this is hopefully not just me but a universal need for everyone.

So, what happened was that I started using the calendar in Lotus Notes, and who ever is responsible for this system does not find this to be a fundamental need: I need to do some clicking before I learn if I’m already booked or if I try to make a booking when people are already busy. And if I accept or suggest a double booking, I’m not prompted or warned. I guess the product owner at Lotus Notes is a super hero with the power to be at several places at the same time, so I guess that is why he haven’t seen this need as a universal, fundamental need for the booking process.

So, what has sneaked into my habits during the months past is that I’m always double booked for meetings. Since I can accept or book meetings without this being flashed in my face, I’ve started to see it as less of a problem. But it is a problem and a bad habit.

But the lesson is more important than so. If we just imagine the product owner of Lotus Notes being that super hero who can be at many meetings at the same time, he can either realize that his reality is a bit different from others, why a need that he doesn’t have is really important. But one cannot wonder how often you just disregard a crucial need just because your reality is a bit different from everyone else.

News in Team Foundation 2010

From a project manager’s point of view

On 2009-06-25, I and a colleague listened to a seminar concerning news in Team Foundation Server (TFS) 2010. We are currently using TFS 2008 mainly for source code handling and tracking progress (using the work item tracking functionality) during projects. Here are my notes.

Fundamental changes

TFS 2010 include a new client, especially for testers, Test Essentials or Test & Lab Management. This will mean that to be able to work effectively as a test leader or tester, you don’t need a Visual Studio installation. It is today unclear how licensing will work with the new client.

The integration with Microsoft Office require Office 2007.

SQL 2008, SP1 is required.

You can run a VS 2010 client against TFS 2008 SP1 and using patches, a user can run VS 2008 against TFS 2010. This enables a step by step upgrading of the environment.

The installation of a new server is complicated and takes a lot of time. You can though make the installation first and make all configuration in a second step, This means that the person responsible for installation does not need all configuration variables to complete the installation.

The possibilities for load balancing has been increased which would enable us to runt TFS on multiple servers and also make use of several SQL Server.

Work item tracking

The most important change here is the possibility to not only link work items but actually specify how items are linked. You can for example:

• Specify a hierarchy. This would mean that we can specify which tests are included in a test plan or which tasks belong to a product backlog item.
• Predecessor/successor relationship. This would mean that we could specify that one task is dependant on the for filling of another task.
• Related items of a specific work item type. This would mean that we could specify requirements in the form of tests and we could then specify on a task Definition of Done in the form of which tests are to be passed to see the task as completed.

A smaller change is that you can group different work item types to ease the creation of reports and queries. Using our current development process, we have no need for this.

The reports are as before available in Reporting Services format but there is an increased number of Excel reports, which also use the data warehouse. This would make us less dependant of reporting services for our project management.

There is also a specific report called Agile Workbook. In this, a number of reports, focused on the product owner and scrum master roles has been gathered.

Building environment

The concept of Gated Build is introduced and means that when a developer checks in, he can make a test build before an actual checkin. This would better hinder checkins which breaks the build.

The build scripts use Workflow 4, which enable a more graphical view of builds.

TFS Admin Console

A new client, targeting the administrator wanting control of his TFS and include the functionality which an administrator needs.

Test & Lab Management

This is a Windows client which does not require Visual Studio and target the needs of the tester. Here a tester can set up test manuscripts, run tests and report bugs. What was also really interesting was that while running tests, a tester can choose to record his steps and when filing a bug, he can automatically send a film or pictures of the situation. The recording can then also be used when verifying that a bug is fixed: the macro retakes all steps to the failing step, which makes the validation faster.

What also was interesting was the possibility to set up virtual environments for different test scenarios, for example different cultural settings and configurations. Since a test is run in a specific environment, we can keep better track of the environment in which the tests are run and not run. Also, when filing bugs, a snapshot of the environment at the time of the failure is possible.

Visual Studio for Architects

The seminar did not cover functionality in Visual Studio but notable is the inclusion of modeling in UML using Visual Studio. Use cases and processes can be directly modeled in Visual studio and linked to code and work items. Also, it is possible to automatically derive a model from a current system.

Since this is stored in the source control system, the models would be source controlled, which means that you can track changes of the system and even see which checkins have changed the model.

Query handling

The visualization of a search result has been improved since you can view a tree view or a link of the items and their directly related items. You can also click and drag to move work items in the hierarchy, for example if you want to move tasks between sprints or product backlog items.

Queries can now be collected in folders and you can also make rights settings these folders to hinder users from accidently changing common queries.

Source control

You can in TFS see graphically how branching and merging has occurred and using a graphical tool merge.

Web client

The user interface in the web access has been improved and include a dashboard functionality to enable views which are specific for the different types of users.

Measuring productivity

You get what you measure

So true, so true. These famous words from Mary Poppendieck point at an important objective of anyone interested in their work.

But there is a risk to these words. Because you can be lead to believe that you can measure everything you want.

I want my son to love me. So, following Mary’s words I should probably measure his love. This should ensure me success in getting his love.

Sounds goofy? Well, to most sane people this sounds crazy. I cannot take out a chart and plot my son’s love for me.

But how about productivity? In the agile community I’ve read a couple of discussions about if you can use velocity to measure productivity. I don’t like this idea much. I use velocity for predictions and my priority. Story point estimates are in my world a relative value of size, and if I start measuring how many dots they complete every month, they are not sure to start making their estimates bigger. I still don’t measure productivity but I’ve also lost my chance of predicting my upcoming deliveries.

So, how do I measure productivity of the developers on my team? Well, I measure it by how happy my users and stakeholders Do they feel that the investment was worth it. But, but, you might say: that is too vague! And I say that just this is what matters. If the customer is happy about the investment. Can they make the money they hade anticipated or save the cost they were counting on.

And frankly, I have a hard time finding a good measurement of productivity. I can just look back at my role; project manager. What is a productive project manager? Is it the one who makes the most Gantt chart bars? Or holds the longest steering groups? How does a project manager know if he’s been productive a day? For me it’s a feeling. Some days I can have had this ten minutes meeting which clarified a lot of stuff which will save us a lot of coding time or make us reach our goals. But a numeric calculation, I don’t know.

It was perhaps easier when I was a test leader. And yet not. A productive tester does not find a lot of bugs, he prevents them from occurring in the first place. And how do you measure that? Yes, you can measure the decline in bugs, but how do you know if a specific tester was the reason.

So, to summarize; I wouldn’t feel productive as a project manager if I was asked to measure the productivity of team members.

Summer issue of Methods & Tools available

http://www.methodsandtools.com/PDF/mt200902.pdf

An issue by solely female writers, and it covers Testers/Developers, Mock Objects, Quantify Quality, Scrum roles, PDD and Open Source messaging services.

Are you planning a project or just drawing a Gantt chart?

I guess the main reason for most project managers to use Microsoft Project is drawing the traditional Gantt chart. It’s kind of obvious, since the Gantt chart view is the default view of the program. This view is also confirmed by the default fields that are visible. A task is in Microsoft Project described by over a hundred fields but only eight of these are visible using the default settings.

If you just start up a default session of Microsoft Project and don’t change any setting, this is how you define a Task:

· Name (Text)

· Duration (Days)

· Start (Date & time, even if only the date is visible)

· Finish (Date & time, even if only the date is visible)

· Predecessors (Numbers – ID of tasks which the task directly depends on)

· Resource Names (Names of Resources)

If you open one of the templates provided by Microsoft, they all look something like this:

There are all these tasks where one leads to the other and where the assignment is already done. You’re supposed to enter the Duration (in Days).

What is important is to understand what Duration is and what it’s not. In agile methodologies such as scrum, when defining tasks during sprint, you estimate how much work a task should result in. In other words; how many man hours it is estimated that a task will result in. This attribute is in Microsoft Project referred to as Work. And that is not the same as Duration. You cannot even see Work with the default settings. Work is what you get when you add resources to a task. But why is this? I believe that it all comes back to what I assume is the basic use for Microsoft Project; drawing the Gantt chart.

The Gantt chart is made up of all these blue bars, all connected to each other and leading to the end of the project. So the assumption of the Gantt chart is that if you make a Gantt chart, you can calculate when the project should be completed. That sounds great! Just what my stakeholders want.

The individual bars in the Gantt chart have a length and a place in time. The length is the attribute Duration, and therefore it makes sense to have the attribute Duration clearly visible and editable. And to place the bar in time you can use two methods, you can either link them together or you can place them on a specific date. The linking information is saved in the field Predecessors and you can specify a date by changing the Start or Finish Columns.

The final touch to the Gantt chart is the displaying of the resources names and that is stored in the field Resource Names.

So, there you have it; the columns in the default view of Microsoft Project are the ones which you need to draw the Gantt chart.

But does this mean that you can calculate the finish date of the project based on this? Well I think that experience talks against this. Just the fact that you cannot see the assumed workload makes the planning blind. And as I’ve previously discussed; since the focus factor is 100%, no holidays are in the system and the slack is 0, we all know that this is an illusion. Looking at the Gantt chart, I see the similarity with stairways and you get the feeling that all tasks are individual steps on the stairways. You just have to walk down that and you’re done. You can just check of the steps as you fly by them. Right.

Another problem with having the Gantt chart as the objective of your planning is what you want to do with that Gantt chart. Yes, you want that planned end date but you also want to show the chart to your steering group. And then you need to print it or take a screen copy and enter it into your PowerPoint presentation. Let’s see what happens when we open one of the templates:

But hey, I can’t see all those bars, and I cannot see all those rows! But then I need to collapse the heading tasks and change the timescale:

But then I’m missing out on my nice blue bars and it looks strange. So, to keep my project nice and clean, it’s better to keep the number of tasks down. Also, linking in the Chart view is a pain if you cannot see all the tasks at the same time.

And here, we also see a conflict with agile values. In most agile methodologies, you want to keep the tasks as small as possible to enable more accurate estimates. But this clutter up the Gantt chart, making it hard to read and linking becomes complicated.

Finally, we have another problem with having the Gantt chart drawing as the objective of our planning. The product backlog does not fit into this scenario. A product backlog is a prioritized list of requirements but this does not mean that the product backlog items are interlinked. So you cannot link them in the Gantt chart. But if you don’t link them, you don’t get your Gantt chart.

Next time you start Microsoft Project, ready to create the plan for you next project, keep your objectives clear; is your goal drawing a dreamy Gantt chart or do you have higher goals?

I’ve on this blog posted a tutorial on using Microsoft Project as a planning tool. I cannot say it’s easy but neither is planning. Thinking that you’ve planned your project just because you have a Gantt chart to show your steering group is a first step towards a challenged project.

There can only be one product owner – reply on harvesting developer intelligence

I got a very interesting reply on my latest blog post concerning the harvesting of the passion of the developers. Kevin E. Schlabach rightly pointed out that you could misinterpret my suggestion to leave some time for developer’s own initiatives and ideas.

So, just to make it clear; product owners can, if they think that the developers have great ideas, keep this in mind and when scheduling deliveries, leave some slack so if a developer comes up with a great idea, you as a product owner can choose to prioritize this. As Kevin points to, this is not up to the developer to decide. He can come with suggestions just like stakeholders, but just like everyone else, he cannot decide on priorities.

I’ve also been in situations where developers have thought up an idea and just started working on that instead of the stuff that needed to be done. To be frank, I’ve had some serious problems with this and finally had to take very drastic steps to end this, so I know that this is an important and serious problem. Serious, since other stuff isn’t being done, and dangerous since cheating in a team in contagious. It spreads to the other developers.

When you instead harvest the developer’s ideas you place them on the backlog like everything else. But I do like to make the guys happy sometimes and push up something on the priority list if it’s a really good idea and something which is truly valuable to the customer. But as a product owner, I am responsible, and it’s my decision to take.

Thanks, Kevin, for pointing to the risks for misunderstanding of my point of view. Keep the comments coming! I’m agile in point of view.

Don’t forget to harvest the passion of the developers

Most of the software developers I’ve worked with want to solve the problems of the users. Many are real professionals with the attitude of a craftsman. Many are innovative about different solutions. And most of them love to write code.

If you take a developer who wants to solve problems, is a craftsman, innovative and loves to write code you are sure to hear loads of good ideas of what he could do, if he only was given the opportunity.

Many times, his suggestions are not highest on the priority list from the business people. And then you run into the situations when his stuff is never done. Yes, I know that there are other stakeholders who’s ideas never becomes a reality too, but this guy stands there with his hands deep into the code every day, thinking about those things he could do, given that he get the opportunity.

So, you should leave some room for that in your plan. For example, if you’re using scrum or another iteration based method, let the guys pick one thing if they are successful in a sprint.

If you’re doing kanban, you can be a little bit more spontaneous. The other day, one of the developers came up with a great idea. I could see the passion in his eyes. He really wanted to do it. And I could hear that he’d given the thought a lot of thinking (this proved to be correctly later). Since we’re in a situation where the next stuff on the list cannot be completed due to lacking resources of a specific competence, I was considering what we should do next. So, why not? So, I said to him to go ahead. Given that the stuff in progress is done, this will be next.

I think we’ll get so much more code/function/quality out of this than we would have if the stuff had been done with someone who didn’t think this was his stuff, someone who wasn’t thrilled about the idea. And this joy about his work will probably continue after his work with this is done. Just because now it’s done.

But besides from sometimes prioritizing the stuff the developers have passion for, one can also help developers becoming more passionate about all the other stuff. And that is best done (I think) by including them in discussions, requirements and story writing.

The difference between knowledge and understanding

We can all hope this is true…

(From Indexed)

Why user stories are not silly

I’m currently reading The Goal, an experience not unlike reading Godel, Escher, Bach in my youth or Sophie’s world a couple of years ago. Using the novel form to explain Business improvement (The Goal), Mathematics (GEB) or philosophy (Sophie’s world) seem like something impossible, but in these three cases the form (which, I grant, is only partly used in GEB) is truly successful. The reason is that the story format probably works well with human brains. It’s like it’s described in Made to Stick; by presenting a story, the information sticks better in our brain.

And yet, it doesn’t seem natural to even consider writing something so important in the novel form. It’s almost like if a subject is grave or important, the presentation should “fit” that. Perhaps this is also the reason for why so many question the user story format. Just the name is probably a hindrance.  Are we going to write “STORIES”. Are you going to gather all developers in a room and write stories. I guess the postits add to the kindergarten feeling most perhaps feel when presented with the user story idea in the first place. I mean, we need the developers to work (AKA, create code).

But stop and think. Like the main character in The Goal does. What’s the goal?

Well, the goal of every IT department should be the same as the rest of the company. And all companies must make money. Perhaps not today or tomorrow, but if you don’t make money, you will never survive.

OK. If the goal is to make money, what do you do next? Well, you should start moving in the direction of making that money. That does not mean that you should only focus on the things that bring in money now. That can, as you probably know, even make you lose money in the long run. Taking on customers who you can’t handle can cost you in the long run. Skipping that training for the developers can make them make simple mistakes. Etc. What is important is not taking the steps in the directions that doesn’t make you earn more money. OK, a company can of course participate in altruistic programs for help organizations, but this is just an exception. When you are at work your tasks should lead to your company making money.

But now the old lady has gone bananas. Starting with some strange books, moving over to user stories and now she’s rambling about making money. Where’s she going with all this?

If we now take that notion of making money down into the deepest corners of the developer’s department and sit down with Greg, the geekiest guy on the block. And we sit there and ask him – How will that piece of code make us make more money? What are the chances that he has no idea or worse; a false image? But why? Because some consider developers just working when they crunch code. That is what makes the company making money. If a developer is not crunching code, he’s not productive.

But what is a productive developer. Well that should be something like this:

Yes, there could also be something that could be disabled and then the two end boxes switch places, but the principle is the same. Now consider these two scenarios.

A: A user wants to do X in system Y and a change request is formed by him and the tasks are handed to a developer, who develops the functionality and delivers to the user.

B: A user wants to do X and discusses this with a developer. The developer informs the user that this functionality is already built into system Z and the user starts using that instead.

So, how was the productivity of the developer in these two scenarios?

How common do you think that this is. Or the scenarios where stuff is built more complicated than needed, or wrongly because something was misunderstood? Or the thousand other cases when the developer simply didn’t know what the user wanted and the user didn’t know his options. When presented with options (not too many but a handful) an intelligent user can often realize that he himself didn’t know what he wanted either.

So, how can we best inject the knowledge into the developer? Well, giving him that specification is a clear path to failure. And in the case of our two scenarios, the specification in itself was waste since it was never needed in the first place.

What we need are more stories. So, is it enough just to use the user story format and give the developers that bunch of story cards?

Have you seen the Dead Parrot sketch by Monty Python? When the sketch was first presented to BBC, they simply wrote down the dialog but no one could see the joke (well, perhaps you don’t like Monty and then it’s never funny) and it wasn’t until they played the stuff the greatness was spotted. And it’s the same with user stories. The actual text is just a reminder, it’s the forming of the story which brings value. Remember that the objective is making money and if we can do that without writing any code at all, we can spend that time on something else. But to enable this, we must use the competence of the developers and the business people at its maximum. And user story workshops are an excellent tool.

Do you use the Spoilt Brat Pattern?

One of the reason for why I started working for TUI Nordic was the view of the customer. Not that the customer’s always right but the customer must feel like he’s right.

All too often do people think that their customer is wrong or should blame himself for not being satisfied. He made the wrong choice, picked the budget alternative and still he has the nerve to complain about it. And when he do complain how many strive at making the customer go away/stop complaining instead of making him content. Sometimes it does not cost you anything. More often than not simple words and explanations can make the customer feel that his issues has been noticed and validated. Yes, you feel that your hotel is too far from the beach and that is why you paid less than the others. Do you want me to check if we can upgrade your reservation? That’s an example of what I mean, instead of making the customer feel stupid you can recognize his problem and find solutions.

And the same goes for development teams. You have a feature developed and when you deliver you find that the customer is not satisfied. In some cases they tell you that you got it all wrong, load and clear. In other cases they don’t use the functions. In both cases there can be frustration that you didn’t understand them but I guess there is also a sense of guilt. Perhaps they helped during specification and testing but it wasn’t until production they realized the problem. So what do you do?

Many turn to the Spoilt Brat Pattern.

Before I got Peter, I used to hate spoilt children. I still hate it, but now I have a better understanding. So, what is a spoilt brat? That’s the kid who gets what he screams about and he’s still not happy. He complains, screams that you got him the wrong one or that he just want something new now.

If you as an adult apply the Spoilt Brat Pattern you turn to the child and say “Hey, you asked for that one. You got it now, so don’t be so spoiled and be happy about what you have. Think about the poor kids in X, they would be thrilled about that one. It’s no fun giving you stuff, because you’re never pleased.”

Spot on, isn’t it. Hm. In software development this would sound like “Hey, we built it like the specification and you did approve to this during testing. Now you have what you wanted. Think about the guys in finance, they have been waiting for their features for a month now. Why should we develop things for you, you’re never pleased with anything.”

Well, yesterday an incident got me thinking. My son Peter really wanted a scooter after testing one at his cousin and a month ago, we went out and got one. I went to a toy store and there it was, blue and Peter approved of it. It wasn’t quite like the one his cousin had but there were no others like that one in the store, so we got this blue one. It looked something like this:

At home, Peter started using the scooter but soon, I realized he wasn’t pleased with it. And he stopped using it. I couldn’t understand why. So, yesterday we started talking about in a store. He saw another scooter and he gloated. So, I asked why he didn’t use his own scooter. This one was just the same, or?

                

But, he finally confessed, you cannot slide with his. Stupid mom as I am I stated that they were the same. No, said Peter. Mine has three wheels, so I can’t slide it when I brake. If I were a better mom I would probably hinder my son from sliding at age four, but instead I realized our mistake. Peter hadn’t understood that the third wheel would hinder him from making that daring stuff he wanted to do and I hadn’t even bothered to learn the difference between the two types of scooters.

If I had played the Spoilt Brat Pattern on Peter, I would have just said that he should be happy about his scooter. But instead I got him the right one instead and gave the other one to another child, whose parents wouldn’t afford one and who won’t do any sliding. Both Peter and I made a mistake by picking out the three-wheeled scooter in the first place and forcing him to use it would be of no good to anyone of us. But, and this is a big but; hadn’t he acknowledged that he himself made the original choice, this story would have had another ending.

So, next time your users are not happy about the features you’ve built, think if you’ve built them the three-wheeled scooter they didn’t really have any use for and try to fix the problem.