Archive for the ‘Process’ Category
In previous posts, we have seen how to use the Six Honest Serving Men to define the elements of a process, while keeping it from becoming stupid. In the latter, one of the items we briefly touched upon was to make Process definition “Practitioner-led.” Today, we’ll dive into this inclusive way a little more.
[In industry jargon, Practitioners are the people who perform the tasks indicated by the process – software development teams, for example.]
Why Practitioners have to participate in process definition? Some common objections encountered are:
- They are not experts in process development
- It is not in their job description or they have other work to do
- If they do it, why do we need process specialists?
While these are valid to some extent, lack of ownership of the very people who have to use the process is the single biggest reason for failure of processes. This isolationist, ivory-tower approach results in processes that are out of touch with reality, do not take into account established practices and a general feeling of “process policing” among the development and project management community.
Most people that I encounter, including die-hard Agile champions, agree that some agreement on how things will be done is necessary when such activities involve many people. A process is such an agreement. When we trust people to develop mission-critical software for us, it is foolish to think that they cannot define an effective way of doing things!
Are you convinced yet? If yes, let us move on and see how we can implement this effective means of defining processes. The title points below are meaningful enough without me trying to elaborate on them.
- Assemble the right team
- Identifying process requirements
- Identifying current practices
- Defining the process
Assembling the right team is probably the most important part of this whole exercise. You need to bring in people of all kinds. You need process champions, critics as well as technical experts.
What about you? You are there to assist them in wording the process, doing the documentation work, creating simple flows and probably to see that process requirements are defined right.
One other thing I have found helpful is to incorporate as many current practices, documents and tools as possible. To do this, you as the process specialist have to talk to people, do the research and generally make it easy for the team to define the process.
A good Practitioner-led process improvement initiative reduces the inertia and encourages others to follow what has been defined by their fellow clan members.
In fact, many guidelines from the SEI show that the use of practitioner-led process improvement journeys lead to sustained improvements in appraisal ratings as well as in achieving project maturity.
Share with me your stories, criticisms and your experiences in the comments below.
In Process – How to develop one that is not stupid, we looked at how we can develop a process that empowers people to do to their thing and not stand in their way. But how do we actually develop one that can assist us in achieving the above goal? Using the concept of Six Honest serving men, we can define a system for activities that involve more than one person. Some of the following content may overlap with other posts, but that’s because they are all related (or maybe I am too dense to write one that explains all).
Why: As I mentioned in a previous post, without stating clearly why we are doing something, it is pretty difficult to convince people to even read something, forget about following it. The Why is often stated in grand terms, and since people are not stupid, they understand it is just for the sake of having it! Have a simple description of the outcome and why following it will help them (in their daily life and not something like, “It will make the organization compliant with the GRAND THEORY OF NOTHING”. Who cares?)
What: What defines the activities that need to be completed to achieve a certain goal. The inputs for this can be based on existing team practices or from best practices in other teams or (God forbid!) from frameworks.
When: When here does not relate to time, but the sequence in which the above activities should be performed.
Who: Code does not get written just because we have defined “Write code”. Someone needs to write it and someone else needs to test it. Mr. Who helps us identify the people to perform the activities in the desired sequence.
Where: This is the easy one. You ask me to enter the bug – fine. Where? You get the idea (please don’t create forms for every small bit of information! Funny one here – http://www.bureauofcommunication.com/compose/romanticintent)
How: This is the most difficult one. If you list out how to do an activity in great detail, your process will be cumbersome and if you don’t give any details, it will not be useful. Err on the less side, since you can always add detail. This is easy to say, but difficult to implement and unfortunately, the answer for how much is, “It depends, at least for me. By the way, do you have any good principles for this? Share with me.
One of the easiest ways to spell out a process is the System flow chart or activity diagram coupled with annotations for inputs/outputs of the process. This makes the process simple, visual and clear.
If you are wondering if this can be used in Agile methods (not using Agile process, in case you are offended. Ha.), the answer is yes. A process is just a structured method of representing what needs to be done and does not mean it needs to be “heavy”; it can be as light as you need. If you come from a process mature organization and want to find out if you can use Agile methods or not, read this interview and then buy the book (disclaimer: I am not affiliated in any way with the author and have not yet read the book completely).
Go on, become a process specialist. May the Force be with you.
“Process” in the software development world has been characterized with colorful adjectives. I am here to defend it.
What is about the word “Process” that makes people run fro cover? I see a lot of people who turn to Agile, not because they realize its worth, but because they think it frees them to do what they want, how they want. Agile is discipline, folks and you can do it only if you have the maturity to handle that discipline on your own.
Here, I am defending a process that is simple, provides clear roles and responsibilities, is changed appropriately when needed and most importantly, the one that is applied well. I am not defending a rule book written in circa 1800.
I hear you. You are saying that process as I defined is not the one that you see everyday in countless organizations. Right. But I ask you, is that the fault of the process? Did it slowly creep into your organizations? No, we wrote it. We are the ones implementing it. We are the ones hiding behind it.
A process is nothing but a set of steps we write to accomplish a particular task. We write it down so that others may follow the path easily and when we have thousands of people doing the same task, we don’t want everyone to do it differently, unless circumstances require.
These exceptional circumstances occur more frequently in the SW dev world than in other places like manufacturing (that is why concepts in manufacturing don’t lend themselves well to SW, but that is for another day).
So what do we need? We should define processes that result in desired outcomes. We need to create awareness that a process needs to be adopted and adapted as the situation changes to make it effective. Let us look at some things that we can do to define a process that is not stupid.
1. Define the Why
There is a better chance that people will follow the process if it is clear why and the why is “reasonable”
For example, for software configuration management, the “why” is to ensure that code is checked-in frequently (to avoid crashes or overwrites), follow naming conventions (to easily determine what the file does/belongs by looking at the file name), follow the structure (to modularize code) etc.
2. Minimize Forms
If people have to fill out forms for every step of the process, be sure that will never be followed. While some amount of paperwork is necessary, it should not detract from actually performing the task. The biggest mistake I see people make is trying to get a lot of information filled out, even when that information is not required or may not be used. There are two reasons for this:
- Incorrect interpretation of process frameworks like CMMI or ISO
- When something goes wrong, find out where and why. The failure points are minimal, but to have some documentation for those failure points
Every activity, whether defined by a process or not, has to be done by someone. Why not ask those people to define the process? It is well-recognized that when a team of practitioners own the process, the adoption is much higher. Do we want someone sitting in an ivory tower to tell me what to do? Nah.
Look for ways to automate as much of the process as possible. If you are capturing information, don’t provide forms for people to capture data. Use tools or write scripts to capture and present that information.
5. Teach people to change it
Make it clear that the process is not sacred. When people start to feel it is not working or not comfortable any longer, change it. Fiercely implement a culture where people can voice their concerns about something that is not working for them.
6. Never talk about the stick
We all know about the “Carrot and Stick”. In this case, however, never ever use the stick. Are we cattle to be driven ahead? Lead us and we’ll follow. What this means is don’t penalize when someone does not follow it. It could be that the process is not usable under stressful situations or the leadership does not care about it. If the manager asks the team to forget about the process just for this urgent request, it shows that the manager does not think the process is useful!
If we follow some of the common-sense principles, any process can be made simple and usable. Otherwise, we will end up defining a complex “Agile” process!
Do you still think Process is stupid? What would you do to help people follow a method that can help them be productive, yet have fun?
This post is based on the “Performance Effects of Measurement and Analysis: Perspectives from CMMI High Maturity Organizations and Appraisers” from the SEI (Relevant page to download the report is here)
The SEI has published a seminal report (although its around 150 pages only), comparing the use of statistical methods and models with high-maturity levels from 2008 and 2009 surveys. The work, as expected, has a lot of details, including validation of the results using statistical analysis!
1. Process Performance Models are used extensively in the areas of defect prediction, cost/schedule performance, estimation accuracy while other areas are relatively low. Interesting: Models for Customer satisfaction are less frequent
2. Many organizations use optimization techniques when building/using process performance models. Monte Carlo simulation and use of probabilistic modeling have grown. Interesting: Other techniques have reduced in popularity, while “don’t know” responses have increased!
3. Level of stakeholder involvement in measurement and analysis is along expected lines with measurement specialists having a high level of involvement. Interesting: It is not clear if all organizations have dedicated measurement specialists or process engineers take on the role as needed. Customer involvement is, predictably, less at organizational level
4. Organizations seem to have invested in training specialists in modeling techniques followed by process engineers. Interesting: It is not clear who the “users” of the models are – in a Software product/service organization, I expect users to be project managers and engineers
5. 75% of managers understand the results of the models well. Interesting: The % itself is interesting, since many of the managers I have met do not understand well how the models are built!
6. Just about 66% of those who build statistical models understand the intent behind it from the CMMI perspective. Interesting: Somehow, this does not resonate well with me. The only explanation I can think of is that the model builders are statisticians who are guided by the Process Engineers in identifying factors, building models and interpreting the results
7. Documenting the models and results well is a significant differentiator for high-maturity organizations. Interesting: No surprise there!
8. Not enough expertise is the only challenge that remained constant between 2008 and 2009. Other reasons have decreased! Interesting: In one year, have our problems decreased? I think in 2008, they were exaggerated!
9. 65% of managers want to use PPMs for knowing when their projects are out of track. Interesting: This is good, because having something just to gain a “high-maturity” tag is not, uh, “high-maturity” [Although, “PPMs are the way in the organization” comes a close second!]
10. There are 5 “healthy” ingredients for a good process performance model that is consistent across many research reports. When all ingredients are present, the value of the PPM to the organization is “substantial”. Interesting: The CMMI does not provide any directions on using such reports as guidance!
1. There are many responses that mention the lack of clarity in what is expected from high-maturity practices.
2. Problems like lack of accurate historical data, wide variation in the type and nature of projects, resources etc continue to plague industry
3. There are no peer-reviewed, published reports on factors to be considered in process performance models. Even common ones like defect prediction do not have standard regression equations, where values/co-efficients can be adjusted based on organizational performance
4. Process Performance Models do not have enough documentation to describe the input data that was used to produce them. This causes resistance in using them well
5. Impact of people variation is not usually considered as a factor, but which often skews actual performance
6. Experts in statistical techniques tend to forget that finding the cause of variation is notoriously difficult in software development, which is what managers are more interested in! Stating variance values often brings up the question – “what is causing the variation?”, for which the answer is “Thats what you have to find out”. Silence.
7. High-maturity organizations often have the management commitment to stay the course even in financial difficulties – they believe that having high maturity practices is a necessary element of beating the competition and hence coming out of the financial crisis. Without this belief, High maturity goals remain another management fad
Read the report a few times to digest it. What conclusions did you draw? What aspects do you observe in your organizations? Did I miss something in my observations?
The most common problem in a Metrics program is defining the "why" for each of the metrics. The second most common problem is getting agreement from all stakeholders on the "what-when-where-which-how" parts of the definition. In this 2-part series, we will look at what you can do to make this easier for your stakeholders to understand what to expect from your metrics approach.
- Defining a Metrics catalog
- Creating standard data collection, reporting and presentation templates
In this part, let us take a look creating a Metrics Catalog to hold the metrics definitions and communicate in an unambiguous way on what the metrics mean and how they will be reported.
Part 2 will look at creating standard templates for the execution, once the metrics are agreed. However, it is often best to gain agreement on the templates along with the definition, since any major change in the templates can cause changes in the mechanics of the definitions.
A Metrics Catalog
A metrics catalog is simply a table with information on the collection and evaluation of Metrics. It can be a spreadsheet with columns for the different parts of the Metric. A set of columns given below can be used as a starting list
Name: Define the metric name. Be careful to make the names consistent (calling one "defect density" and the as "other % reduction in defects across testing cycles " doesn’t help!)
Inputs: What are the raw inputs that you will be using for this metric
Tip: A Metric is always a relationship between two entities")
Formula: How will be the metric be computed? Describe the relationship in mathematical terms.
Objective: Describe the intent of this metric – how will you interpret the values of this metric
Tip: Use general descriptors for the interpretation – don’t say, for example, "if the value is <99%, it means we are not doing good." Rather, say "the values for this metric will help us determine how our customers perceive our services")
Data Source: Identify where the inputs will come from and if possible, who is responsible to collect this information. This is one of the fields where the more detailed the information is, the easier it is for everybody later.
Unit of Measure: Describe the units for the values of the Metric. Is it % or defects/Lines of Code or just a number. Be very careful with this as this will impact how you will report the metrics in a visual form
Target Values: Describe the acceptable range of values for the metric
Tip: Be cautious with this, if you don’t have historical data. Leave it blank for the first few periods and then fill it in with the best performance of the actual values. Once you have sufficient samples, you can devise a proper target value).
Tip 2: Be extra cautious with “industry benchmarks”. Unless they are really similar, don’t thrust them on your organization or you will encounter lot of resistance to the metrics initiative)
Frequency of collection: Describe how often will you collect the inputs, compute and report the metric
Tip: As much as possible, try to keep the frequency constant for all the metrics in the Catalog. Think Collection=Reporting -just because data is available weekly, it doesn’t mean you need to collect and report it weekly.)
Area: Describe which area of the product/service lifecycle does this metric belong to.
Type of metric: List if it is a leading metric or lagging one