We Few, We Unhappy Few

Uncle Bob Martin recently blogged about the hordes of untrained developers coming into the industry, which eventually leads to some huge software disasters. James Bach wrote about the failures of HealthCare.gov that stemmed from incompetence in software management. These are very good articles, that make you think: Should software professionals (developers, testers, managers) be regulated?

Let’s start with the why: Obviously, most of the (first) world runs on software. We either produce it as a product, or run our company on it. In any case, software is a critical component in business. It makes sense that we’d want to to keep out the riff-raff. Software is too important to leave to the unprofessional.

Would you want an untrained person, posing as a plumber to handle your pipes? (Yes, pun intended). Of course not. And that goes triple for your business.

Why regulate?

We usually try to regulate when we have suffered a massive abuse of our trust. We start with our lives, then our livelihood. We trust doctors (some, including me, say too much) because they went through required tests. We regulate banks  (badly) because they’ve taken away our money and spent it on bonuses for incompetent executives. In normal countries, we try to avoid regulation as much as we can, because it invites gaming the system, which plays badly in a free market. Not that the free market is free of gaming. Regulation, in theory, is there to create trust.

So if we want to trust software, where do we start?

How does regulated software world look like?

Of course, the simplest thing is to regulate developers. For example, you’d need to show you have decent skills in software before you can write commercial software. We won’t discuss what’s decent here (I guess we can come up with a common ground. Ok, I’m pretty sure we can’t, but let’s continue either way). This will probably be something more than what students learn today at universities, since when they come into the real world, we and them find what they’ve learned there is 90% useless. On a good day.

Once we’ve accepted this level of competence, we’ll immediately create another industry: the software licensing administration. Like any administration it sucks money from where it really ought to go. And with clear cut defined competency levels, there’ll be training and licensing organizations ready to take a young developer’s money in order to qualify. Much like a university or college degree, it gets devalued pretty quickly. But on the upside, since there’s a money invested, it does keep away some people. The poor ones.

Like any administration, it’s here to last, and so are its competency definitions. That’s right, in 50 years time, there are still going to be questions about C++ standard strings. These things do not get updated frequently.

This doesn’t look too good. The system keeps away talent, while letting in the people who bought “Programming license for dummies”. That won’t raise the quality of software.

The current situation is not that different, by the way: we’re using the universities and colleges as a gateway. We can however bypass these rules when we identify someone with actual experience. With the new legislations, the bar just moves (it doesn’t necessarily move higher).

We’re not managing risk, we’re just adding complexity to the process, and bleeding money along the way.

The big question

So what can really make sure software quality is raised to a professional level?

The craftsmanship movement says it’s the software developers who are responsible to raise their level.  While I agree, it will work only for those who accept the challenge. That leaves, what 80% of developers out of the loop? And I’m generous. An honorable demand, but conflicts with the reality.

In order to raise the level of quality, we need a demand of professionalism from the business side. That requires understanding of what building software is from the business side, which is no small fit. The business people need to fear for their wallet for funding reckless software projects. The business needs to pay for putting out risky code, because only then it will require professionalism from their workers. when this happens, weeding out the unprofessional will become part of the business, from hiring to respecting the professional developer. Uncle Bob mentions a few companies got the gist and are taking responsibility.

Chances of that happening in the rest of the software world? The same as with bankers, insurance providers and doctors. 

If you’re reading this, you’re probably on the craftsmanship side of ship. If it starts sinking, it’s because most of the horde is tipping the other side.

I hope you weren’t expecting a clear upbeat answer. Pack a life jacket.

Share Button

Leave a Reply

%d bloggers like this: