Hacker News Reader

Comment by open-source-ux | Hacker News Reader

"This should induce criminal charges not against the software developer, it should induce charges against management"

This is often repeated by developers and it reeks of hypocrisy. Of course management must be implicated, but so must be the developers. Innocent developers are not simply helpless cogs in the machine coerced by management.

This blameless attitude held by many developers permeates the software industry. Whether it's the Volkswagen emissions scandal, ad-tech, or widespread online tracking - these were conceived, built and implemented by developers. And yet developers think they stand apart blameless from the consequences of their shoddy practices.

I wonder if the Fujitsi developers, far removed from the Post Office staff, have ever stopped to consider that the software they wrote ruined the lives of so many people.

View on HN

> the Volkswagen emissions scandal, ad-tech, or widespread online tracking

Those aren't bugs. The first was a fraud that developers actively participated in.

Not only developers, it also wasn't a secret. This kind of cheating was a well known fact in the industry, to the point that car-specialised journals were reporting on it a decade before the scandal "broke out".

No, developers might be responsible for accounting errors. Everything that came after that is completely out of their hands. You cannot assert competence or complicity by the number of bugs. That is far more dependent on the testing environment and the complexity of the software.

And yes, developers are pretty regularly "cogs in the machine" when it comes to define the development conditions. Especially in large corporations like Fujitsu.

> I wonder if the Fujitsi developers, far removed from the Post Office staff, have ever stopped to consider that the software they wrote ruined the lives of so many people.

They may not even be aware that they worked on this. Or they may have relayed concerns about schedule pressure making errors inevitable, or may be working in an environment where no such concerns can ever be raised.

It seems likely that they're working in the before-testing times which correlates strongly with risk of the above.

I wonder about the procurement process that lead to Fujitsu supplying the UK post office. This might be an instance of the public sector picking the cheapest from N bids then looking surprised when cheapest turns out to mean crap.

All you say are plausible scenarios. But there is also another one: the developers were simply not very good at writing code - neither diligent, thorough, or aware of good practices. Or they simply didn't care about the bugs or errors even if they knew about them. They never had to suffer the consequences.

The developers in question probably don't even work for Fujitsu. They probably work outside the UK, in the software equivalent of a sweatshop, and spend most of their time copy-pasting from Stack Overflow and writing the kind of incoherent GitHub issue comments that every maintainer of a high-profile OSS project has to deal with these days. They provide the single-digit-dollars-per-hour code output, and Fujitsu makes sure the requirements are vague enough that they can meet them with the resulting dumpster fire, and this is the result.

It's not hypocrisy - taking responsibility is one of the reasons management exists in the first place.

> taking responsibility is one of the reasons management exists in the first place

Yet how many times do we hear a senior manager or politician claim they "take full responsibility" but not resign, and then attempt to carry on as before?

"Taking responsibility" has become a meaningless phrase.

Developers are in fact a cog in the machine. They do not define or even have possibility to define the overall process that should counter this. Some times they don't even know the scope of the use of what they are working on. That is squarely on management, and that is also why management should be responsible for a failure like this if they didn't put a reasonable process in place.

The reason for this is quite simply because it's impossible to develop bug free code. The process needs to reflect this, and if it doesn't it's not the individual developers fault.

Reply on news.ycombinator.com