We have been using function points for the past 18 months. I am responsible for our function point program and I am beginning to think that life was much simpler without them. Function Point Analysis is a technique used for measuring the functional size of a delivered piece of software. Simply stated, it provides the quantification of features and functions that my user has asked me to deliver. The methodology is pretty straightforward, using techniques and terms that are easy to understand and mathematical formulas that we learned in the third grade. I have been using function points for two purposes: to estimate / predict software delivery outcomes and to measure performance (i.e. productivity and quality).
In my shop, everyone is asked to estimate their projects. The project estimates are to include predicted levels of effort, cost and delivery schedules. We use function points as a size indicator because it makes sense that if you have to accurately predict how long and how much effort developing a piece of software is going to take, that you should have some sense of its size. Of course, there are other variables you have to solve for, like complexity and how you plan to manage the development of a particular piece of software given its size and complexity. I actually find function points to be a good indicator of size and very useful in helping me articulate exactly which features and functions we are actually going to deliver to our end user. This ultimately makes it easier to discuss estimates with our end user and to manage their expectations. So, what's the problem?
In my shop, things are always changing. Customers are frequently making last minute changes to what they want delivered or a project’s key resources are being borrowed for other projects that are in trouble. It makes it very difficult to accurately predict outcomes, and ultimately, projects are occasionally not delivered on time or within budget. And every time one of these failures occurs, it seems like folks are quick to blame function points. Function points become the convenient focal point of all that is wrong with a failed project. The logic behind this thinking is that function points must not have accurately sized the project and therefore, we could not properly predict the outcomes. I find myself constantly defending function points and pointing out what the real culprit(s) for these occasional failures are; e.g. ambiguous requirements, changing priorities, resource constraints (take your pick!). Without function points to blame, everyone could go back to blaming each other for the project failures that occur, and my life would be much simpler.
As I mentioned earlier, we are also using function points to measure things like productivity and product quality. It is pretty cool. We measure the function points we deliver and use effort and cost to determine a rate of delivery and a cost per function point, two key performance indicators. We can also show a comparative value across projects by using function points as a normalizing factor when assessing the number of defects delivered for a piece of software, a measure known as defect density.
Sounds pretty good, doesn't it!? You would think that these measures would be good information to have. Well, here's the issue. In my shop, people are not held accountable for properly recording their time; therefore, we don't do a very good job of accurately recording time spent on our projects. And so what happens is, once people know that performance is being measured, they get a little crazy. They start changing their behavior. They find that they can “game” the system and start recording their time such that they can make their performance numbers look better. In addition, folks aren't held accountable for recording defects, and so getting any kind of consistent or accurate defect information is a challenge as well. Obviously, all of this distorts the measures and impacts their credibility.
So, once again, if we stopped using these darn function points, we could find any number of alternative excuses for our project mishaps – just like we used to. It would allow for greater creativity and resourcefulness on the part of project managers that are trying to save their rear-ends. Rather than use their fingers to count function points, they could use their fingers to point at and to blame others. That way they can't be held accountable (or learn from their failures). And it would make my life so much simpler.
Vice President, Software Performance Management