

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

Would something like that work?<p>The bugs obviously would be relatively harmless ones, perhaps not even noticeable by most users.
======
scott_s
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.

~~~
amichail
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.

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

~~~
amichail
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.

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

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

~~~
scott_s
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.

~~~
amichail
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.

~~~
scott_s
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.

------
gclaramunt
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...

~~~
amichail
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.

------
amichail
Intentional error therapy is described here:

[http://books.google.ca/books?id=w6ESB0Ys4IoC&pg=RA1-PA24...](http://books.google.ca/books?id=w6ESB0Ys4IoC&pg=RA1-PA248&lpg=RA1-PA248&dq=perfectionism+%22intentional+errors%22&source=bl&ots=xr3CG6iS8g&sig=b71qE-
dsTc0jxZ8la49Hy0J_tqI&hl=en&ei=U0zpSaXXCMyrtge6jfCXBg&sa=X&oi=book_result&ct=result&resnum=1)

------
rml
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._ )

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

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

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

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

~~~
amichail
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).

