Programming can exacerbate perfectionism. Why not intentionally introduce bugs as a cure? | Hacker News Reader

Programming can exacerbate perfectionism. Why not intentionally introduce bugs as a cure?

4 pointsamichail18 comments

Would something like that work?

The bugs obviously would be relatively harmless ones, perhaps not even noticeable by most users.

Because it would intentionally give us more work.

The "perfectionism" does not come from being bug-free, for me. It comes from expressing the solution in the most elegant way. And I don't consider that a bad thing: allowing myself time to refactor as I go along makes the code easier to maintain and extend, saving me time.

The problem is that perfectionism can turn into paralysis, which is much worse than having an app with some relatively harmless bugs and/or design flaws.

If the imperfection of your code paralyzes you, then you have problems that are unrelated to programming, and introducing artificial bugs won't help.

But some bugs turn the user experience into paralysis. How do we know beforehand which intentional bugs will only be harmless?

Display bugs are pretty harmless (e.g., a label being a few pixels off its correct position). Also, consistency bugs are hard to notice sometimes.

These bugs irritate the developer, but probably not the user.

There's more to "user experience" than display.

What do you mean? One could restrict the intentional bugs to various types that are known to be minor.

Say, something as basic as passing around user data. Bork that and the user is paralyzed.

Software systems are already complex and difficult to reason about. Intentionally making them more complex with no appreciable gain and more difficult to reason about for a problem a tiny fraction of the population has seems like a Bad Idea.

Introduced bugs would be guaranteed to be minor by restricting them to types where you can ensure that this is the case.

There is no need to do any of this if none of your developers suffer from this problem.

But I suspect that many developers will get this problem as a result of their profession.

When reasoning about the system, one still has to reason about the introduced bugs, because it's always possible there's a bug in the introduction of bugs. In fact, given the difficulty of proving the correctness of non-trivial programs, I think it's likely the introduced bugs would bleed out into the rest of the system.

I sincerely doubt any developers would "get this problem." The behavior you're describing is severe OCD. You don't catch it like a cold. If one's OCD is that severe, it will probably manifest in many more areas of their lives than just programming.

There's also the fact that most developers work in teams, and the people who don't have this form of OCD would not tolerate having purposefully introduced bugs. I know I wouldn't.

That sound like a not really smart idea. If the product is good enough, ship it, that's the project leader (or whoever is "in charge") job. I don't know what perfectionism the post refers, but time spent improving performance, maintainability, etc, is an investment (that may or may not pay). Introducing bugs seems a double whammy: a significant effort must be put at introducing bugs so they're not critical and then fixing them, at least think on the carbon-footprint of that waste! Besides, any non trivial project had enough bugs/enhancements to keep even the best programmers busy...

You could have tools that automatically introduce minor bugs. And you would ship with these minor bugs.

The idea is to force an environment on your developers where perfectionism is impossible. And so this may have positive mental health benefits.

Intentional error therapy is described here:

http://books.google.ca/books?id=w6ESB0Ys4IoC&pg=RA1-PA24...

Brings to mind a quote from Minsky on his preference for sloppy, corrective programming:

"Don't try to fix the bug, just put in some code that notices when it's about to happen, and heads it off."

(From Stewart Brand's The Media Lab: Inventing the Future at MIT.)

Perhaps you might like to use Fault Injection in your next project.

http://en.wikipedia.org/wiki/Fault_injection

Taking things further, one can even imagine therapy tools that automatically introduce relatively minor bugs.

Stupid idea. Computers are already hard enough to deal with without introducing bugs on purpose.

Computers are probably mostly to blame for perfectionism.

Maybe we could find ways to use computers to cure it (e.g., using tools to introduce bugs automatically).

Reply on news.ycombinator.com