Measuring developer productivity? A response to McKinsey
newsletter.pragmaticengineer.com
newsletter.pragmaticengineer.com
I see software engineering more as a team sport than as an individual sport. In team sports, each individual sacrifices some metrics for the good of the team.
Here is my rant about how soccer teams would perform if they were evaluated like the McKinsey-style nonsense becoming pervasive in the tech industry: https://medium.com/@NTDF9/if-soccer-managers-did-performance...
> For example, one company found that its most talented developers were spending excessive time on noncoding activities such as design sessions or managing interdependencies across teams. In response, the company changed its operating model and clarified roles and responsibilities to enable those highest-value developers to do what they do best: code.
How dare our senior dev leads spend time _designing_, we need hands on keyboards!!!
> CEOs and CFOs are increasingly frustrated by [...] software engineering is too nuanced to measure, when sales teams have individual measurements and quotas to hit, as do recruitment teams in the number of positions to fill. The executive reasoning goes: if other groups can measure individual performance, it’s absurd that engineering cannot."
It's absurd to think that those other can be! THAT is the flaw!
Those measurements and quotas of sales/marketing/recruitment/etc are hugely corrupting! They lead to selling features that don't exist and cannot exist. They lead to bad hires. This same incorrect thinking leads directly to Teaching-to-the-test. To bureaucratic grant proposal systems. And most likely tons more that I just don't know about. Measuring the wrong thing is pervasive.
That the article thinks other fields can be measured without corruption totally undermines the entire article. This is exactly why McKinsey are stupid enough to think programmers can be measured: because they are not programmers. Exactly like how politicians think they can measure teachers: they are not teachers.
Every one of the listed decisions can be made effectively without an operationalization[1][2] of developer productivity and the sooner a playbook of methods takes over, the better.
1. https://en.wikipedia.org/wiki/Operationalization
2. Campbell,Norman Robert. Physics The Elements 1920 https://archive.org/details/physicstheelemen029733mbp
Even wall painters are surprisingly hard to measure. Painting the wall without noticing issues with the underlying preparation will cause an unhappy customer at the end. Painting the wall with the color the customer has chosen without making sure the customer realizes that the color looks WAY darker on an entire wall compared to the small sample, will also lead to an unhappy worker.
It's very popular to think there are other professions that are easy to measure, and yet it's never your own productivity that can be measured.
It's madness that we aren't just saying that productivity of ANY KIND is damn hard to measure!
I wish I was on a team of engineers who just did their work and didn't worry about gaming the system. I wish the engineers I worked with had enough time to be careful that such small mistakes, which are difficult to track down after the fact, did not make it to prod to cause our customers grief. I wish that management was competent enough to know that adding a missing quotation mark to the repo isn't just adding a missing quotation mark to the repo.
I hope that place has exit interviews later so you can freely tell them on the way out how bad this is. But considering how bad it is, it would surprise me.
Send your boss a link to "Negative 2000 Lines of Code"[1] and ask him if he thinks Bill was a shitty coder.
When I was scrum master for two teams I, too, tracked some metrics (for feedback and improvement, not for pay or career (ab)use).
While I did track the number of story points delivered and user stories closed per sprint, one of the things I was more interested in was how accurately the teams managed to hit their estimates (regardless of what they were). In that perspective, delivering too much too quickly was just as undesired as the opposite. We used this to refine the way that we did estimates, story refinement, and sprint planning.
Naturally these were team-based metrics, because software development is a team activity.
[1] https://www.folklore.org/StoryView.py?story=Negative_2000_Li...
Applying those same metrics to individuals is too tempting for a subpar manager. The data is right there!