As it is wont to do, the conversation about productivity has come up around the office again. Like many development shops, we fail to measure any form of productivity at all. And the primary reason we don’t measure productivity is not because we don’t track where our employees’ time goes, but because we don’t track how much work they’re doing.
See, unlike a factory which produces, say, nuts and bolts, it is difficult to count a delivered unit of functionality in software. The conventional options seem to fail us. Lines of code (LOC) is troublesome because even in an unwatched environment, the person to person variability in how many lines of code you write to get something done is quite different. Once you begin monitoring people for how many lines of code they write it encourages them to write extra lines of code, whether they are necessary for the functionality or not, in order to inflate their productivity.
The other measure commonly used, but still problematic is Function Points (FPs). FPs don’t get heavy adoption because it requires expertise to implement (plus ongoing costs) AND it turns out that developers can actually overcomplicate their design to increase the number of function points delivered – an undesirable result.
Maybe this is self evident, but the problem with both of these measures is that they aren’t independently verifiable. Instead, the counting of productivity (whether it be LOC or FPs) depends heavily on the person whose productivity you are measuring. By comparison, if you were at a factory of any kind, a layperson can count how many units come out the door. How much you produce can be verified independent of having any assistance in figuring it out.
So, what does this mean? If our existing measures of productivity can be gamed, what are we left with? Here’s my idea: we use one team in the company to measure the other. For example, we measure developer productivity in the number of test cases needed to verify all the functionality they deliver. The (perhaps big) assumption is that they developer delivers no more functionality than requested by the business, and thus the cases meant to verify that said functionality were delivered act as an independent verification of the developer. Now, since the tester is acting as the counter, you cannot measure the tester’s productivity as cost / test case executed, since that would encourage the person acting as your measurement system to want to needlessly increase the number of test cases. Indeed, we should measure testers not on cases ran but on valid defects detected, since it is their job to appraise the system and writing unnecessary test cases doesn’t add to the appraisal process.
In this way, the measurement system balances itself. The test organization measures the developers’ productivity via developer effort / test case needed to verify delivered functionality. The development organization watches over the test team because they can cancel invalid defects. Each team acts as the independent verifier of the other, thus escaping the issue of putting both the work and the reporting of how much work got done in the hands of a single team.
Posted by ProcessRants
Posted by ProcessRants
Posted by ProcessRants